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
.core
.tests
.component
;
15 import java
.io
.IOException
;
16 import java
.util
.Vector
;
18 import junit
.framework
.TestCase
;
20 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
21 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
22 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
23 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
24 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
25 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfEndSynchSignal
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfStartSynchSignal
;
28 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.component
.TmfEventProviderStub
;
29 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.component
.TmfSyntheticEventProviderStub
;
30 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.event
.TmfSyntheticEventStub
;
31 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
34 * <b><u>TmfClientTest</u></b>
36 * Test suite for the TmfEventProvider class.
38 @SuppressWarnings({ "nls" })
39 public class TmfEventProviderTest
extends TestCase
{
41 TmfEventProviderStub fEventProvider
;
42 TmfSyntheticEventProviderStub fSyntheticEventProvider
;
44 public TmfEventProviderTest(String name
) throws IOException
{
49 protected void setUp() throws Exception
{
51 fEventProvider
= new TmfEventProviderStub();
52 fSyntheticEventProvider
= new TmfSyntheticEventProviderStub();
56 protected void tearDown() throws Exception
{
58 fEventProvider
.dispose();
59 fSyntheticEventProvider
.dispose();
62 // ------------------------------------------------------------------------
63 // getProviders (more a sanity check than a test)
64 // ------------------------------------------------------------------------
66 @SuppressWarnings("unchecked")
67 public void testGetProviders() {
69 // There should be 2 TmfEvent providers: a TmfTraceStub and a
70 // TmfEventProviderStub
71 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class);
72 assertEquals("getProviders", 2, eventProviders
.length
);
74 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
75 assertEquals("getProviders", 1, eventProviders
.length
);
77 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
78 assertEquals("getProviders", 1, eventProviders
.length
);
80 // There should be 1 TmfSyntheticEventStub provider
81 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
82 assertEquals("getProviders", 1, eventProviders
.length
);
85 // ------------------------------------------------------------------------
87 // ------------------------------------------------------------------------
89 @SuppressWarnings("unchecked")
90 public void testGetPlainEvents() {
92 final int BLOCK_SIZE
= 100;
93 final int NB_EVENTS
= 1000;
94 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
96 // Get the TmfSyntheticEventStub provider
97 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class,
98 TmfEventProviderStub
.class);
99 ITmfDataProvider
<TmfEvent
> provider
= eventProviders
[0];
101 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
102 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
104 public void handleData(TmfEvent event
) {
105 super.handleData(event
);
106 requestedEvents
.add(event
);
110 provider
.sendRequest(request
);
112 request
.waitForCompletion();
113 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
114 assertTrue("isCompleted", request
.isCompleted());
115 assertFalse("isCancelled", request
.isCancelled());
117 // Make that we have distinct events.
118 // Don't go overboard: we are not validating the stub!
119 for (int i
= 0; i
< NB_EVENTS
; i
++) {
120 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
122 } catch (InterruptedException e
) {
127 @SuppressWarnings("unchecked")
128 public void testCancelRequests() {
130 final int BLOCK_SIZE
= 100;
131 final int NB_EVENTS
= 1000;
132 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1
= 10;
133 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2
= 800;
135 final Vector
<TmfEvent
> requestedEventsReq1
= new Vector
<TmfEvent
>();
136 final Vector
<TmfEvent
> requestedEventsReq2
= new Vector
<TmfEvent
>();
138 // Get the TmfSyntheticEventStub provider
139 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class,
140 TmfEventProviderStub
.class);
141 ITmfDataProvider
<TmfEvent
> provider
= eventProviders
[0];
143 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
145 // Create first request
146 final TmfEventRequest
<TmfEvent
> request1
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
148 public void handleData(TmfEvent event
) {
149 super.handleData(event
);
150 requestedEventsReq1
.add(event
);
152 // cancel sub request
153 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1
) {
159 // Synchronize requests
160 ((TmfEventProviderStub
) provider
).startSynch(new TmfStartSynchSignal(0));
162 // Additionally, notify provider for up-coming requests
163 provider
.notifyPendingRequest(true);
165 // Call sendRequest, which will create a coalescing request, but it
166 // doesn't send request1 yet
167 provider
.sendRequest(request1
);
169 // Check if request1 is not running yet.
170 assertFalse("isRunning", request1
.isRunning());
172 // Create second request
173 final TmfEventRequest
<TmfEvent
> request2
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
175 public void handleData(TmfEvent event
) {
176 super.handleData(event
);
177 requestedEventsReq2
.add(event
);
179 // cancel sub request which will cancel also main request
180 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2
) {
186 // Call sendRequest, which will create a coalescing request, but it
187 // doesn't send request2 yet
188 provider
.sendRequest(request2
);
190 // Check if request1/2 is not running yet.
191 assertFalse("isRunning", request1
.isRunning());
192 assertFalse("isRunning", request2
.isRunning());
194 // Send end synch signal, however requests won't be sent
195 ((TmfEventProviderStub
) provider
).endSynch(new TmfEndSynchSignal(0));
197 // Check if request1/2 is not running yet.
198 assertFalse("isRunning", request1
.isRunning());
199 assertFalse("isRunning", request2
.isRunning());
201 // Finally, trigger sending of requests
202 provider
.notifyPendingRequest(false);
206 // Wait until requests start
207 request1
.waitForStart();
208 request2
.waitForStart();
210 // // Verify that the requests are running
211 // assertTrue("isRunning", request1.isRunning());
212 // assertTrue("isRunning", request2.isRunning());
214 request1
.waitForCompletion();
216 // // Check if request2 is still running
217 // assertTrue("isRunning", request2.isRunning());
219 // Verify result (request1)
220 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1
, requestedEventsReq1
.size());
221 assertTrue("isCompleted", request1
.isCompleted());
222 assertTrue("isCancelled", request1
.isCancelled());
224 request2
.waitForCompletion();
226 // Verify result (request2)
227 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2
, requestedEventsReq2
.size());
228 assertTrue("isCompleted", request2
.isCompleted());
229 assertTrue("isCancelled", request2
.isCancelled());
231 } catch (InterruptedException e
) {
236 @SuppressWarnings("unchecked")
237 private void getSyntheticData(final TmfTimeRange range
, final int nbEvents
, final int blockSize
) throws InterruptedException
{
239 final Vector
<TmfSyntheticEventStub
> requestedEvents
= new Vector
<TmfSyntheticEventStub
>();
241 // Get the event provider
242 ITmfDataProvider
<TmfSyntheticEventStub
>[] eventProviders
= (ITmfDataProvider
<TmfSyntheticEventStub
>[]) TmfProviderManager
243 .getProviders(TmfSyntheticEventStub
.class);
244 ITmfDataProvider
<TmfSyntheticEventStub
> provider
= eventProviders
[0];
246 final TmfEventRequest
<TmfSyntheticEventStub
> request
= new TmfEventRequest
<TmfSyntheticEventStub
>(TmfSyntheticEventStub
.class, range
,
247 nbEvents
, blockSize
) {
249 public void handleData(TmfSyntheticEventStub event
) {
250 super.handleData(event
);
251 requestedEvents
.add(event
);
254 provider
.sendRequest(request
);
256 request
.waitForCompletion();
258 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
259 assertTrue("isCompleted", request
.isCompleted());
260 assertFalse("isCancelled", request
.isCancelled());
262 // For each base event, the stub will queue 2 identical synthetic events
263 // Ensure that the events are queued properly.
264 // Don't go overboard: we are not validating the stub!
265 for (int i
= 0; i
< (nbEvents
/ 2); i
++) {
266 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(2 * i
+ 0).getTimestamp().getValue());
267 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(2 * i
+ 1).getTimestamp().getValue());
271 // The following tests are the same but for the size of the requested blocks
272 // with regards to the size of the TmfSyntheticEventProviderStub block
273 public void testGetSyntheticEvents_EqualBlockSizes() {
274 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
276 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
277 } catch (InterruptedException e
) {
282 public void testGetSyntheticEvents_SmallerBlock() {
283 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
285 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
/ 2);
286 } catch (InterruptedException e
) {
291 public void testGetSyntheticEvents_LargerBlock() {
292 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
294 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
* 2);
295 } catch (InterruptedException e
) {
300 public void testGetSyntheticEvents_TimeRange() {
301 TmfTimestamp start
= new TmfTimestamp(1, (byte) -3, 0);
302 TmfTimestamp end
= new TmfTimestamp(1000, (byte) -3, 0);
303 TmfTimeRange range
= new TmfTimeRange(start
, end
);
305 getSyntheticData(range
, -1, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
306 } catch (InterruptedException e
) {
311 // public void testGetSyntheticEvents_WeirdTimeRange1() {
312 // TmfTimestamp start = TmfTimestamp.BigBang;
313 // TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3,
315 // TmfTimeRange range = new TmfTimeRange(start, end);
317 // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
318 // } catch (InterruptedException e) {
323 // public void testGetSyntheticEvents_WeirdTimeRange2() {
324 // TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte)
326 // TmfTimestamp end = TmfTimestamp.BigCrunch;
327 // TmfTimeRange range = new TmfTimeRange(start, end);
329 // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
330 // } catch (InterruptedException e) {
335 // ------------------------------------------------------------------------
336 // getProviders (more a sanity check than a test)
337 // ------------------------------------------------------------------------
339 @SuppressWarnings("unchecked")
340 public void testGetProviders2() {
342 // There should be 2 TmfEvent providers: a TmfTraceStub and a
343 // TmfEventProviderStub
344 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class);
345 assertEquals("getProviders", 2, eventProviders
.length
);
347 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
348 assertEquals("getProviders", 1, eventProviders
.length
);
350 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
351 assertEquals("getProviders", 1, eventProviders
.length
);
353 // There should be 1 TmfSyntheticEventStub provider
354 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
355 assertEquals("getProviders", 1, eventProviders
.length
);