1 /*******************************************************************************
2 * Copyright (c) 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 * Simon Delisle - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.request
;
15 import static org
.junit
.Assert
.assertEquals
;
16 import static org
.junit
.Assert
.assertFalse
;
17 import static org
.junit
.Assert
.assertTrue
;
18 import static org
.junit
.Assert
.fail
;
19 import static org
.junit
.Assume
.assumeTrue
;
21 import java
.util
.ArrayList
;
22 import java
.util
.LinkedList
;
23 import java
.util
.List
;
25 import org
.eclipse
.core
.resources
.IResource
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.ctfadaptor
.CtfTmfEvent
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.ctfadaptor
.CtfTmfTrace
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfEventRequest
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTimeSynchSignal
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.shared
.CtfTmfTestTrace
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
37 import org
.junit
.After
;
38 import org
.junit
.Before
;
39 import org
.junit
.Ignore
;
40 import org
.junit
.Rule
;
41 import org
.junit
.Test
;
42 import org
.junit
.rules
.TestRule
;
43 import org
.junit
.rules
.Timeout
;
46 * Test suite for the scheduler.
48 public class TmfSchedulerTest
{
50 /** Time-out tests after 60 seconds */
52 public TestRule globalTimeout
= new Timeout(60000);
54 // ------------------------------------------------------------------------
56 // ------------------------------------------------------------------------
58 private static final CtfTmfTestTrace testTrace
= CtfTmfTestTrace
.KERNEL
;
59 private static final int NB_EVENTS_TRACE
= 695319;
60 private static final int NB_EVENTS_TIME_RANGE
= 155133;
62 // ------------------------------------------------------------------------
64 // ------------------------------------------------------------------------
66 private CtfTmfTrace fixture
;
68 private long fStartTime
;
69 private long fEndTime
;
70 private TmfTimeRange fForegroundTimeRange
;
72 private final List
<String
> fOrderList
= new ArrayList
<>();
73 private int fForegroundId
= 0;
74 private int fBackgroundId
= 0;
77 * Perform pre-test initialization.
79 * @throws TmfTraceException
80 * If the test trace is not found
83 public void setUp() throws TmfTraceException
{
84 assumeTrue(testTrace
.exists());
85 fixture
= new CtfTmfTrace();
86 fixture
.initTrace((IResource
) null, testTrace
.getPath(), CtfTmfEvent
.class);
87 fixture
.indexTrace(true);
88 fStartTime
= fixture
.getStartTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
89 fEndTime
= fixture
.getEndTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
91 long foregroundStartTime
= fStartTime
+ ((fEndTime
- fStartTime
) / 4);
92 long foregroundEndTime
= fStartTime
+ ((fEndTime
- fStartTime
) / 2);
93 fForegroundTimeRange
= new TmfTimeRange(new TmfTimestamp(foregroundStartTime
, ITmfTimestamp
.NANOSECOND_SCALE
, 0), new TmfTimestamp(foregroundEndTime
, ITmfTimestamp
.NANOSECOND_SCALE
, 0));
97 * Perform post-test clean-up.
100 public void tearDown() {
101 if (fixture
!= null) {
106 // ------------------------------------------------------------------------
108 // ------------------------------------------------------------------------
111 * Test one background request
114 public void backgroundRequest() {
115 BackgroundRequest background
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
116 fixture
.sendRequest(background
);
118 background
.waitForCompletion();
119 } catch (InterruptedException e
) {
122 assertEquals(NB_EVENTS_TRACE
, background
.getNbEvents());
126 * Test one foreground request
129 public void foregroundRequest() {
130 ForegroundRequest foreground
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
131 fixture
.sendRequest(foreground
);
133 foreground
.waitForCompletion();
134 } catch (InterruptedException e
) {
137 assertEquals(NB_EVENTS_TRACE
, foreground
.getNbEvents());
141 * Test one foreground and one background request for the entire trace at
145 public void TestMultiRequest1() {
146 BackgroundRequest background
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
147 ForegroundRequest foreground
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
149 fixture
.sendRequest(background
);
150 fixture
.sendRequest(foreground
);
152 background
.waitForCompletion();
153 foreground
.waitForCompletion();
154 } catch (InterruptedException e
) {
158 assertEquals(NB_EVENTS_TRACE
, background
.getNbEvents());
159 assertEquals(NB_EVENTS_TRACE
, foreground
.getNbEvents());
163 * Test one background request for the entire trace and one foreground
164 * request for smaller time range
167 public void TestMultiRequest2() {
168 BackgroundRequest background2
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
169 ForegroundRequest foreground2
= new ForegroundRequest(fForegroundTimeRange
);
171 fixture
.sendRequest(background2
);
172 fixture
.sendRequest(foreground2
);
174 background2
.waitForCompletion();
175 foreground2
.waitForCompletion();
176 } catch (InterruptedException e
) {
180 assertEquals(NB_EVENTS_TRACE
, background2
.getNbEvents());
181 assertEquals(NB_EVENTS_TIME_RANGE
, foreground2
.getNbEvents());
185 * Test two foreground request, one to select a time range and one to select
186 * an event in this time range
189 public void TestMultiRequest3() {
190 ForegroundRequest foreground3
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
191 fixture
.sendRequest(foreground3
);
193 TmfTimeSynchSignal signal3
= new TmfTimeSynchSignal(this, new TmfTimestamp(fForegroundTimeRange
.getStartTime()));
194 fixture
.broadcast(signal3
);
197 foreground3
.waitForCompletion();
198 } catch (InterruptedException e
) {
202 assertEquals(NB_EVENTS_TRACE
, foreground3
.getNbEvents());
206 * Test two foreground request, one to select a time range and one to select
207 * an event before this time range
210 public void TestMultiRequest4() {
211 ForegroundRequest foreground4
= new ForegroundRequest(fForegroundTimeRange
);
212 fixture
.sendRequest(foreground4
);
213 TmfTimeSynchSignal signal4
= new TmfTimeSynchSignal(this, new TmfTimestamp(fStartTime
+ ((fEndTime
- fStartTime
) / 8)));
214 fixture
.broadcast(signal4
);
217 foreground4
.waitForCompletion();
218 } catch (InterruptedException e
) {
222 assertEquals(NB_EVENTS_TIME_RANGE
, foreground4
.getNbEvents());
226 * Test two foreground request, one to select a time range and one to select
227 * an event after this time range
230 public void TestMultiRequest5() {
231 ForegroundRequest foreground5
= new ForegroundRequest(fForegroundTimeRange
);
232 fixture
.sendRequest(foreground5
);
233 TmfTimeSynchSignal signal5
= new TmfTimeSynchSignal(this, new TmfTimestamp(fEndTime
- ((fEndTime
- fStartTime
) / 4)));
234 fixture
.broadcast(signal5
);
237 foreground5
.waitForCompletion();
238 } catch (InterruptedException e
) {
242 assertEquals(NB_EVENTS_TIME_RANGE
, foreground5
.getNbEvents());
246 * Test one background and one foreground request for the entire trace and
247 * one foreground request to select an event
250 public void TestMultiRequest6() {
251 BackgroundRequest background6
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
252 ForegroundRequest foreground6
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
254 fixture
.sendRequest(background6
);
255 fixture
.sendRequest(foreground6
);
257 TmfTimeSynchSignal signal6
= new TmfTimeSynchSignal(this, new TmfTimestamp(fStartTime
+ ((fEndTime
- fStartTime
) / 8)));
258 fixture
.broadcast(signal6
);
261 background6
.waitForCompletion();
262 foreground6
.waitForCompletion();
263 } catch (InterruptedException e
) {
267 assertEquals(NB_EVENTS_TRACE
, background6
.getNbEvents());
268 assertEquals(NB_EVENTS_TRACE
, foreground6
.getNbEvents());
272 * Four request, two foreground and two background
275 public void TestMultiRequest7() {
276 ForegroundRequest foreground7
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
277 ForegroundRequest foreground8
= new ForegroundRequest(fForegroundTimeRange
);
278 BackgroundRequest background7
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
279 BackgroundRequest background8
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
280 fixture
.sendRequest(foreground7
);
281 fixture
.sendRequest(foreground8
);
282 fixture
.sendRequest(background7
);
283 fixture
.sendRequest(background8
);
285 foreground7
.waitForCompletion();
286 foreground8
.waitForCompletion();
287 background7
.waitForCompletion();
288 background8
.waitForCompletion();
289 } catch (InterruptedException e
) {
292 assertEquals(NB_EVENTS_TRACE
, foreground7
.getNbEvents());
293 assertEquals(NB_EVENTS_TIME_RANGE
, foreground8
.getNbEvents());
294 assertEquals(NB_EVENTS_TRACE
, background7
.getNbEvents());
295 assertEquals(NB_EVENTS_TRACE
, background8
.getNbEvents());
299 * One long foreground request and one short foreground request, the short
300 * one should finish first
303 public void preemptedForegroundRequest() {
304 ForegroundRequest foreground9
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
305 TmfTimeRange shortTimeRange
= new TmfTimeRange(new TmfTimestamp(fStartTime
, ITmfTimestamp
.NANOSECOND_SCALE
, 0), new TmfTimestamp(fStartTime
+ ((fEndTime
- fStartTime
) / 16), ITmfTimestamp
.NANOSECOND_SCALE
, 0));
306 ForegroundRequest shortForeground
= new ForegroundRequest(shortTimeRange
);
307 fixture
.sendRequest(foreground9
);
308 fixture
.sendRequest(shortForeground
);
310 shortForeground
.waitForCompletion();
311 } catch (InterruptedException e
) {
314 assertFalse(foreground9
.isCompleted());
318 * One long background request and one short foreground request, the
319 * foreground request should finish first
322 public void preemptedBackgroundRequest() {
323 BackgroundRequest background9
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
324 ForegroundRequest foreground10
= new ForegroundRequest(fForegroundTimeRange
);
325 fixture
.sendRequest(background9
);
326 fixture
.sendRequest(foreground10
);
328 foreground10
.waitForCompletion();
329 } catch (InterruptedException e
) {
332 assertTrue(foreground10
.isCompleted());
333 assertFalse(background9
.isCompleted());
337 * Test if the scheduler is working as expected
341 public void executionOrder() {
342 List
<String
> expectedOrder
= new LinkedList
<>();
343 expectedOrder
.add("FOREGROUND1");
344 expectedOrder
.add("FOREGROUND2");
345 expectedOrder
.add("FOREGROUND3");
346 expectedOrder
.add("FOREGROUND4");
347 expectedOrder
.add("BACKGROUND1");
348 expectedOrder
.add("FOREGROUND1");
349 expectedOrder
.add("FOREGROUND2");
350 expectedOrder
.add("FOREGROUND3");
351 expectedOrder
.add("FOREGROUND4");
352 expectedOrder
.add("BACKGROUND2");
358 BackgroundRequest background1
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
359 BackgroundRequest background2
= new BackgroundRequest(TmfTimeRange
.ETERNITY
);
361 ForegroundRequest foreground1
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
362 ForegroundRequest foreground2
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
363 ForegroundRequest foreground3
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
364 ForegroundRequest foreground4
= new ForegroundRequest(TmfTimeRange
.ETERNITY
);
366 fixture
.sendRequest(foreground1
);
367 fixture
.sendRequest(foreground2
);
368 fixture
.sendRequest(foreground3
);
369 fixture
.sendRequest(foreground4
);
370 fixture
.sendRequest(background1
);
371 fixture
.sendRequest(background2
);
373 foreground1
.waitForCompletion();
374 foreground2
.waitForCompletion();
375 foreground3
.waitForCompletion();
376 foreground4
.waitForCompletion();
377 background1
.waitForCompletion();
378 background2
.waitForCompletion();
379 } catch (InterruptedException e
) {
382 assertEquals(expectedOrder
, fOrderList
.subList(0, expectedOrder
.size()));
385 // ------------------------------------------------------------------------
387 // ------------------------------------------------------------------------
389 private class BackgroundRequest
extends TmfEventRequest
{
390 private int nbEvents
= 0;
391 private String backgroundName
;
393 BackgroundRequest(TmfTimeRange timeRange
) {
394 super(fixture
.getEventType(),
397 ITmfEventRequest
.ALL_DATA
,
398 ExecutionType
.BACKGROUND
);
399 backgroundName
= getExecType().toString() + ++fBackgroundId
;
403 public void handleData(final ITmfEvent event
) {
404 super.handleData(event
);
405 synchronized (fOrderList
) {
406 if (fOrderList
.isEmpty() || !fOrderList
.get(fOrderList
.size() - 1).equals(backgroundName
)) {
407 fOrderList
.add(backgroundName
);
413 public int getNbEvents() {
418 private class ForegroundRequest
extends TmfEventRequest
{
419 private int nbEvents
= 0;
420 private String foregroundName
;
422 ForegroundRequest(TmfTimeRange timeRange
) {
423 super(fixture
.getEventType(),
426 ITmfEventRequest
.ALL_DATA
,
427 ExecutionType
.FOREGROUND
);
428 foregroundName
= getExecType().toString() + ++fForegroundId
;
432 public void handleData(final ITmfEvent event
) {
433 super.handleData(event
);
434 synchronized (fOrderList
) {
435 if (fOrderList
.isEmpty() || !fOrderList
.get(fOrderList
.size() - 1).equals(foregroundName
)) {
436 fOrderList
.add(foregroundName
);
442 public int getNbEvents() {