1 /*******************************************************************************
2 * Copyright (c) 2013, 2015 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 * Alexandre Montplaisir - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.tracecompass
.tmf
.ctf
.core
.tests
.event
;
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
.Assume
.assumeTrue
;
20 import org
.eclipse
.jdt
.annotation
.NonNull
;
21 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEvent
;
22 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfLostEvent
;
23 import org
.eclipse
.tracecompass
.tmf
.core
.request
.ITmfEventRequest
;
24 import org
.eclipse
.tracecompass
.tmf
.core
.request
.TmfEventRequest
;
25 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.ITmfTimestamp
;
26 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfNanoTimestamp
;
27 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimeRange
;
28 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimestamp
;
29 import org
.eclipse
.tracecompass
.tmf
.ctf
.core
.event
.CtfTmfEvent
;
30 import org
.eclipse
.tracecompass
.tmf
.ctf
.core
.tests
.shared
.CtfTmfTestTrace
;
31 import org
.eclipse
.tracecompass
.tmf
.ctf
.core
.trace
.CtfTmfTrace
;
32 import org
.junit
.After
;
33 import org
.junit
.Before
;
34 import org
.junit
.Test
;
37 * Tests to verify that lost events are handled correctly.
39 * Be wary if you are using Babeltrace to cross-check those values. There could
40 * be a bug in Babeltrace with regards to lost events. See
41 * http://bugs.lttng.org/issues/589
43 * It's not 100% sure at this point which implementation is correct, so for now
44 * these tests assume the Java implementation is the right one.
46 * @author Alexandre Montplaisir
48 public class CtfTmfLostEventsTest
{
50 private static final CtfTmfTestTrace testTrace
= CtfTmfTestTrace
.HELLO_LOST
;
52 private CtfTmfTrace fixture
= null;
59 assumeTrue(testTrace
.exists());
60 fixture
= testTrace
.getTrace();
61 fixture
.indexTrace(true);
68 public void tearDown() {
69 if (fixture
!= null) {
74 // ------------------------------------------------------------------------
76 // ------------------------------------------------------------------------
79 * Test that the number of events is reported correctly (a range of lost
80 * events is counted as one event).
83 public void testNbEvents() {
84 final long expectedReal
= 32300;
85 final long expectedLost
= 562;
87 EventCountRequest req
= new EventCountRequest();
88 fixture
.sendRequest(req
);
90 req
.waitForCompletion();
91 } catch (InterruptedException e
) {
95 assertEquals(expectedReal
, req
.getReal());
96 assertEquals(expectedLost
, req
.getLost());
100 * Test getting the first lost event from the trace.
103 public void testFirstLostEvent() {
104 final long rank
= 153;
105 final ITmfTimestamp start
= new TmfNanoTimestamp(1376592664828848222L);
106 final ITmfTimestamp end
= new TmfNanoTimestamp(1376592664828848540L);
107 final long nbLost
= 859;
109 final CtfTmfEvent ev
= getOneEventTime(start
);
110 /* Make sure seeking by rank yields the same event */
111 final CtfTmfEvent ev2
= getOneEventRank(rank
);
112 assertEquals(ev
, ev2
);
114 assertTrue(ev
instanceof ITmfLostEvent
);
115 ITmfLostEvent event
= (ITmfLostEvent
) ev
;
117 assertEquals(start
, event
.getTimestamp());
118 assertEquals(start
, event
.getTimeRange().getStartTime());
119 assertEquals(end
, event
.getTimeRange().getEndTime());
120 assertEquals(nbLost
, event
.getNbLostEvents());
124 * Test getting the second lost event from the trace.
127 public void testSecondLostEvent() {
128 final long rank
= 191;
129 final ITmfTimestamp start
= new TmfNanoTimestamp(1376592664829402521L);
130 final ITmfTimestamp end
= new TmfNanoTimestamp(1376592664829403076L);
131 final long nbLost
= 488;
133 final CtfTmfEvent ev
= getOneEventTime(start
);
134 /* Make sure seeking by rank yields the same event */
135 final CtfTmfEvent ev2
= getOneEventRank(rank
);
136 assertEquals(ev
, ev2
);
138 assertTrue(ev
instanceof ITmfLostEvent
);
139 ITmfLostEvent event
= (ITmfLostEvent
) ev
;
141 assertEquals(start
, event
.getTimestamp());
142 assertEquals(start
, event
.getTimeRange().getStartTime());
143 assertEquals(end
, event
.getTimeRange().getEndTime());
144 assertEquals(nbLost
, event
.getNbLostEvents());
148 * Test getting one normal event from the trace (lost events should not
152 public void testNormalEvent() {
153 final long rank
= 200;
154 final ITmfTimestamp ts
= new TmfNanoTimestamp(1376592664829423928L);
156 final CtfTmfEvent event
= getOneEventTime(ts
);
157 /* Make sure seeking by rank yields the same event */
158 final CtfTmfEvent event2
= getOneEventRank(rank
);
159 assertEquals(event
, event2
);
161 assertFalse(event
instanceof ITmfLostEvent
);
162 assertEquals(ts
, event
.getTimestamp());
165 // ------------------------------------------------------------------------
167 // ------------------------------------------------------------------------
169 private CtfTmfEvent
getOneEventRank(long rank
) {
170 OneEventRequestPerRank req
= new OneEventRequestPerRank(rank
);
171 fixture
.sendRequest(req
);
173 req
.waitForCompletion();
174 } catch (InterruptedException e
) {
177 return req
.getEvent();
180 private CtfTmfEvent
getOneEventTime(@NonNull ITmfTimestamp ts
) {
181 OneEventRequestPerTs req
= new OneEventRequestPerTs(ts
);
182 fixture
.sendRequest(req
);
184 req
.waitForCompletion();
185 } catch (InterruptedException e
) {
188 return req
.getEvent();
191 private class OneEventRequestPerRank
extends TmfEventRequest
{
193 private CtfTmfEvent event
= null;
195 public OneEventRequestPerRank(long rank
) {
196 super(CtfTmfEvent
.class, TmfTimeRange
.ETERNITY
, rank
, 1, ExecutionType
.FOREGROUND
);
200 public void handleData(ITmfEvent ev
) {
201 /* Type is checked by the request, cast should be safe */
202 event
= (CtfTmfEvent
) ev
;
205 public CtfTmfEvent
getEvent() {
210 private class OneEventRequestPerTs
extends TmfEventRequest
{
212 private CtfTmfEvent event
= null;
214 public OneEventRequestPerTs(@NonNull ITmfTimestamp ts
) {
215 super(CtfTmfEvent
.class,
216 new TmfTimeRange(ts
, TmfTimestamp
.BIG_CRUNCH
),
217 0, 1, ExecutionType
.FOREGROUND
);
221 public void handleData(ITmfEvent ev
) {
222 event
= (CtfTmfEvent
) ev
;
225 public CtfTmfEvent
getEvent() {
230 private class EventCountRequest
extends TmfEventRequest
{
232 private long nbReal
= 0;
233 private long nbLost
= 0;
235 public EventCountRequest() {
236 super(CtfTmfEvent
.class, TmfTimeRange
.ETERNITY
, 0,
237 ITmfEventRequest
.ALL_DATA
, ExecutionType
.FOREGROUND
);
241 public void handleData(ITmfEvent event
) {
242 if (event
instanceof ITmfLostEvent
) {
249 public long getReal() {
253 public long getLost() {