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
.util
.Vector
;
17 import junit
.framework
.TestCase
;
19 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
20 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
21 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
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
;
45 * @param name the test anme
47 public TmfEventProviderTest(String name
) {
52 protected void setUp() throws Exception
{
54 fEventProvider
= new TmfEventProviderStub();
55 fSyntheticEventProvider
= new TmfSyntheticEventProviderStub();
59 protected void tearDown() throws Exception
{
61 fEventProvider
.dispose();
62 fSyntheticEventProvider
.dispose();
65 // ------------------------------------------------------------------------
66 // getProviders (more a sanity check than a test)
67 // ------------------------------------------------------------------------
72 public void testGetProviders() {
74 // There should be 2 TmfEvent providers: a TmfTraceStub and a
75 // TmfEventProviderStub
76 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class);
77 assertEquals("getProviders", 2, eventProviders
.length
);
79 eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
80 assertEquals("getProviders", 1, eventProviders
.length
);
82 eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
83 assertEquals("getProviders", 1, eventProviders
.length
);
85 // There should be 1 TmfSyntheticEventStub provider
86 eventProviders
= TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
87 assertEquals("getProviders", 1, eventProviders
.length
);
90 // ------------------------------------------------------------------------
92 // ------------------------------------------------------------------------
97 public void testGetPlainEvents() {
99 final int BLOCK_SIZE
= 100;
100 final int NB_EVENTS
= 1000;
101 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
103 // Get the TmfSyntheticEventStub provider
104 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class,
105 TmfEventProviderStub
.class);
106 ITmfDataProvider provider
= eventProviders
[0];
108 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
109 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
111 public void handleData(ITmfEvent event
) {
112 super.handleData(event
);
113 requestedEvents
.add(event
);
117 provider
.sendRequest(request
);
119 request
.waitForCompletion();
120 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
121 assertTrue("isCompleted", request
.isCompleted());
122 assertFalse("isCancelled", request
.isCancelled());
124 // Make that we have distinct events.
125 // Don't go overboard: we are not validating the stub!
126 for (int i
= 0; i
< NB_EVENTS
; i
++) {
127 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
129 } catch (InterruptedException e
) {
137 public void testCancelRequests() {
139 final int BLOCK_SIZE
= 100;
140 final int NB_EVENTS
= 1000;
141 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1
= 10;
142 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2
= 800;
144 final Vector
<ITmfEvent
> requestedEventsReq1
= new Vector
<ITmfEvent
>();
145 final Vector
<ITmfEvent
> requestedEventsReq2
= new Vector
<ITmfEvent
>();
147 // Get the TmfSyntheticEventStub provider
148 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class,
149 TmfEventProviderStub
.class);
150 ITmfDataProvider provider
= eventProviders
[0];
152 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
154 // Create first request
155 final TmfEventRequest request1
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
157 public void handleData(ITmfEvent event
) {
158 super.handleData(event
);
159 requestedEventsReq1
.add(event
);
161 // cancel sub request
162 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1
) {
168 // Synchronize requests
169 ((TmfEventProviderStub
) provider
).startSynch(new TmfStartSynchSignal(0));
171 // Additionally, notify provider for up-coming requests
172 provider
.notifyPendingRequest(true);
174 // Call sendRequest, which will create a coalescing request, but it
175 // doesn't send request1 yet
176 provider
.sendRequest(request1
);
178 // Check if request1 is not running yet.
179 assertFalse("isRunning", request1
.isRunning());
181 // Create second request
182 final TmfEventRequest request2
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
184 public void handleData(ITmfEvent event
) {
185 super.handleData(event
);
186 requestedEventsReq2
.add(event
);
188 // cancel sub request which will cancel also main request
189 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2
) {
195 // Call sendRequest, which will create a coalescing request, but it
196 // doesn't send request2 yet
197 provider
.sendRequest(request2
);
199 // Check if request1/2 is not running yet.
200 assertFalse("isRunning", request1
.isRunning());
201 assertFalse("isRunning", request2
.isRunning());
203 // Send end synch signal, however requests won't be sent
204 ((TmfEventProviderStub
) provider
).endSynch(new TmfEndSynchSignal(0));
206 // Check if request1/2 is not running yet.
207 assertFalse("isRunning", request1
.isRunning());
208 assertFalse("isRunning", request2
.isRunning());
210 // Finally, trigger sending of requests
211 provider
.notifyPendingRequest(false);
215 // Wait until requests start
216 request1
.waitForStart();
217 request2
.waitForStart();
219 // // Verify that the requests are running
220 // assertTrue("isRunning", request1.isRunning());
221 // assertTrue("isRunning", request2.isRunning());
223 request1
.waitForCompletion();
225 // // Check if request2 is still running
226 // assertTrue("isRunning", request2.isRunning());
228 // Verify result (request1)
229 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1
, requestedEventsReq1
.size());
230 assertTrue("isCompleted", request1
.isCompleted());
231 assertTrue("isCancelled", request1
.isCancelled());
233 request2
.waitForCompletion();
235 // Verify result (request2)
236 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2
, requestedEventsReq2
.size());
237 assertTrue("isCompleted", request2
.isCompleted());
238 assertTrue("isCancelled", request2
.isCancelled());
240 } catch (InterruptedException e
) {
245 private static void getSyntheticData(final TmfTimeRange range
,
246 final int nbEvents
, final int blockSize
) throws InterruptedException
{
248 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
250 // Get the event provider
251 ITmfDataProvider
[] eventProviders
= TmfProviderManager
252 .getProviders(TmfSyntheticEventStub
.class);
253 ITmfDataProvider provider
= eventProviders
[0];
255 final TmfEventRequest request
= new TmfEventRequest(TmfSyntheticEventStub
.class, range
,
256 nbEvents
, blockSize
) {
258 public void handleData(ITmfEvent event
) {
259 super.handleData(event
);
260 requestedEvents
.add(event
);
263 provider
.sendRequest(request
);
265 request
.waitForCompletion();
266 if (nbEvents
!= -1) {
267 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
269 assertTrue("isCompleted", request
.isCompleted());
270 assertFalse("isCancelled", request
.isCancelled());
272 // For each base event, the stub will queue 2 identical synthetic events
273 // Ensure that the events are queued properly.
274 // Don't go overboard: we are not validating the stub!
275 for (int i
= 0; i
< (nbEvents
/ 2); i
++) {
276 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(2 * i
+ 0).getTimestamp().getValue());
277 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(2 * i
+ 1).getTimestamp().getValue());
284 // The following tests are the same but for the size of the requested blocks
285 // with regards to the size of the TmfSyntheticEventProviderStub block
286 public void testGetSyntheticEvents_EqualBlockSizes() {
287 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
289 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
290 } catch (InterruptedException e
) {
298 public void testGetSyntheticEvents_SmallerBlock() {
299 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
301 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
/ 2);
302 } catch (InterruptedException e
) {
310 public void testGetSyntheticEvents_LargerBlock() {
311 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
313 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
* 2);
314 } catch (InterruptedException e
) {
322 public void testGetSyntheticEvents_TimeRange() {
323 TmfTimestamp start
= new TmfTimestamp(1, (byte) -3, 0);
324 TmfTimestamp end
= new TmfTimestamp(1000, (byte) -3, 0);
325 TmfTimeRange range
= new TmfTimeRange(start
, end
);
327 getSyntheticData(range
, -1, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
328 } catch (InterruptedException e
) {
333 // public void testGetSyntheticEvents_WeirdTimeRange1() {
334 // TmfTimestamp start = TmfTimestamp.BigBang;
335 // TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3,
337 // TmfTimeRange range = new TmfTimeRange(start, end);
339 // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
340 // } catch (InterruptedException e) {
345 // public void testGetSyntheticEvents_WeirdTimeRange2() {
346 // TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte)
348 // TmfTimestamp end = TmfTimestamp.BigCrunch;
349 // TmfTimeRange range = new TmfTimeRange(start, end);
351 // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
352 // } catch (InterruptedException e) {
357 // ------------------------------------------------------------------------
358 // getProviders (more a sanity check than a test)
359 // ------------------------------------------------------------------------
364 public void testGetProviders2() {
366 // There should be 2 TmfEvent providers: a TmfTraceStub and a
367 // TmfEventProviderStub
368 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class);
369 assertEquals("getProviders", 2, eventProviders
.length
);
371 eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
372 assertEquals("getProviders", 1, eventProviders
.length
);
374 eventProviders
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
375 assertEquals("getProviders", 1, eventProviders
.length
);
377 // There should be 1 TmfSyntheticEventStub provider
378 eventProviders
= TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
379 assertEquals("getProviders", 1, eventProviders
.length
);