1 /*******************************************************************************
2 * Copyright (c) 2013, 2014 Ericsson
4 * All rights reserved. This program and the accompanying materials are made
5 * 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 * Patrick Tasse - Updates to mipmap feature
11 *******************************************************************************/
13 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.statesystem
.mipmap
;
15 import static org
.junit
.Assert
.assertEquals
;
16 import static org
.junit
.Assert
.assertNotNull
;
17 import static org
.junit
.Assert
.fail
;
19 import org
.eclipse
.jdt
.annotation
.NonNull
;
20 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.statesystem
.mipmap
.TmfStateSystemOperations
;
21 import org
.eclipse
.tracecompass
.statesystem
.core
.ITmfStateSystemBuilder
;
22 import org
.eclipse
.tracecompass
.statesystem
.core
.StateSystemFactory
;
23 import org
.eclipse
.tracecompass
.statesystem
.core
.backend
.IStateHistoryBackend
;
24 import org
.eclipse
.tracecompass
.statesystem
.core
.backend
.InMemoryBackend
;
25 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.AttributeNotFoundException
;
26 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.StateValueTypeException
;
27 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.TimeRangeException
;
28 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.TmfStateValue
;
29 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.ITmfStateValue
.Type
;
30 import org
.junit
.BeforeClass
;
31 import org
.junit
.Test
;
34 * @author Patrick Tasse
37 public class TmfMipmapStateProviderWeightedTest
{
39 @NonNull private static final String SSID
= "mipmap-test";
40 private static final String TEST_ATTRIBUTE_NAME
= TmfMipmapStateProviderStub
.TEST_ATTRIBUTE_NAME
;
41 private static final long END_TIME
= 250000L;
42 private static final long INTERVAL
= 1000L;
43 private static final int RESOLUTION
= 2;
44 private static final double DELTA
= 0.0001;
45 private static ITmfStateSystemBuilder ssqi
;
46 private static ITmfStateSystemBuilder ssqd
;
49 * Startup code, build a state system with uneven state durations
52 public static void init() {
53 /* setup for INTEGER test */
54 TmfMipmapStateProviderStub mmpi
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.INTEGER
);
55 IStateHistoryBackend bei
= new InMemoryBackend(0);
56 ITmfStateSystemBuilder ssbi
= StateSystemFactory
.newStateSystem(SSID
, bei
);
57 mmpi
.assignTargetStateSystem(ssbi
);
59 /* setup for DOUBLE test */
60 TmfMipmapStateProviderStub mmpd
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.DOUBLE
);
61 IStateHistoryBackend bed
= new InMemoryBackend(0);
62 ITmfStateSystemBuilder ssbd
= StateSystemFactory
.newStateSystem(SSID
, bed
);
63 mmpd
.assignTargetStateSystem(ssbd
);
66 * Every 10,000 ns chunk contains the following states:
68 * | null | 10 | null | 20 | null | 30 | null |
69 * 0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10,000
71 * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14.
73 for (int i
= 0; i
< END_TIME
/ INTERVAL
/ 10; i
++) {
74 long time
= i
* 10 * INTERVAL
;
75 /* update for INTEGER test */
76 mmpi
.processEvent(mmpi
.createEvent(time
, null));
77 mmpi
.processEvent(mmpi
.createEvent(time
+ 1000, 10L));
78 mmpi
.processEvent(mmpi
.createEvent(time
+ 2000, null));
79 mmpi
.processEvent(mmpi
.createEvent(time
+ 3000, 20L));
80 mmpi
.processEvent(mmpi
.createEvent(time
+ 5000, null));
81 mmpi
.processEvent(mmpi
.createEvent(time
+ 6000, 30L));
82 mmpi
.processEvent(mmpi
.createEvent(time
+ 9000, null));
83 /* update for DOUBLE test */
84 mmpd
.processEvent(mmpd
.createEvent(time
, null));
85 mmpd
.processEvent(mmpd
.createEvent(time
+ 1000, 10L));
86 mmpd
.processEvent(mmpd
.createEvent(time
+ 2000, null));
87 mmpd
.processEvent(mmpd
.createEvent(time
+ 3000, 20L));
88 mmpd
.processEvent(mmpd
.createEvent(time
+ 5000, null));
89 mmpd
.processEvent(mmpd
.createEvent(time
+ 6000, 30L));
90 mmpd
.processEvent(mmpd
.createEvent(time
+ 9000, null));
92 /* cleanup for INTEGER test */
93 mmpi
.processEvent(mmpi
.createEvent(END_TIME
, 0L));
95 ssqi
.waitUntilBuilt();
96 /* cleanup for DOUBLE test */
97 mmpd
.processEvent(mmpd
.createEvent(END_TIME
, 0L));
99 ssqd
.waitUntilBuilt();
103 * Test a query range to the state system to get the maximum value in the
104 * range. The test values are INTEGER.
107 public void testQueryMipmapRangeMaxInteger() {
110 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
111 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 0, quark
));
112 assertEquals(10, TmfStateSystemOperations
.queryRangeMax(ssqi
, 500, 1500, quark
).unboxInt());
113 assertEquals(20, TmfStateSystemOperations
.queryRangeMax(ssqi
, 1500, 5000, quark
).unboxInt());
114 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 5000, 10000, quark
).unboxInt());
115 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 10000, quark
).unboxInt());
116 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqi
, 120000, 120000, quark
));
117 assertEquals(10, TmfStateSystemOperations
.queryRangeMax(ssqi
, 120500, 121500, quark
).unboxInt());
118 assertEquals(20, TmfStateSystemOperations
.queryRangeMax(ssqi
, 121500, 125000, quark
).unboxInt());
119 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 125000, 130000, quark
).unboxInt());
120 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 120000, 130000, quark
).unboxInt());
121 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 100000, 150000, quark
).unboxInt());
122 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 240000, 250000, quark
).unboxInt());
123 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 250000, quark
).unboxInt());
124 assertEquals(00, TmfStateSystemOperations
.queryRangeMax(ssqi
, 250000, 250000, quark
).unboxInt());
126 } catch (AttributeNotFoundException e
) {
127 fail(e
.getMessage());
128 } catch (StateValueTypeException e
) {
129 fail(e
.getMessage());
130 } catch (TimeRangeException e
) {
131 fail(e
.getMessage());
136 * Test a query range to the state system to get the minimum value in the
137 * range. The test values are INTEGER.
140 public void testQueryMipmapRangeMinInteger() {
143 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
144 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 0, quark
));
145 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 500, 1500, quark
).unboxInt());
146 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 1500, 5000, quark
).unboxInt());
147 assertEquals(30, TmfStateSystemOperations
.queryRangeMin(ssqi
, 5000, 10000, quark
).unboxInt());
148 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 10000, quark
).unboxInt());
149 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqi
, 120000, 120000, quark
));
150 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 120500, 121500, quark
).unboxInt());
151 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 121500, 125000, quark
).unboxInt());
152 assertEquals(30, TmfStateSystemOperations
.queryRangeMin(ssqi
, 125000, 130000, quark
).unboxInt());
153 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 120000, 130000, quark
).unboxInt());
154 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 100000, 150000, quark
).unboxInt());
155 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 240000, 250000, quark
).unboxInt());
156 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 250000, quark
).unboxInt());
157 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 250000, 250000, quark
).unboxInt());
159 } catch (AttributeNotFoundException e
) {
160 fail(e
.getMessage());
161 } catch (StateValueTypeException e
) {
162 fail(e
.getMessage());
163 } catch (TimeRangeException e
) {
164 fail(e
.getMessage());
169 * Test a query range to the state system to get the average value in the
170 * range. The test values are INTEGER.
173 public void testQueryMipmapRangeAvgInteger() {
176 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
177 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 0, quark
), DELTA
);
178 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 500, 1500, quark
), DELTA
);
179 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 1500, 5000, quark
), DELTA
);
180 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 5000, 10000, quark
), DELTA
);
181 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 10000, quark
), DELTA
);
182 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 20000, quark
), DELTA
);
183 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 500, 20500, quark
), DELTA
);
184 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 1000, 21000, quark
), DELTA
);
185 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 2000, 22000, quark
), DELTA
);
186 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 3000, 23000, quark
), DELTA
);
187 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 4000, 24000, quark
), DELTA
);
188 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 5000, 25000, quark
), DELTA
);
189 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120000, 120000, quark
), DELTA
);
190 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120500, 121500, quark
), DELTA
);
191 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 121500, 125000, quark
), DELTA
);
192 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 125000, 130000, quark
), DELTA
);
193 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120000, 130000, quark
), DELTA
);
194 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 100000, 150000, quark
), DELTA
);
195 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 240000, 250000, quark
), DELTA
);
196 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 250000, quark
), DELTA
);
197 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 250000, 250000, quark
), DELTA
);
199 } catch (AttributeNotFoundException e
) {
200 fail(e
.getMessage());
201 } catch (TimeRangeException e
) {
202 fail(e
.getMessage());
203 } catch (StateValueTypeException e
) {
204 fail(e
.getMessage());
209 * Test a query range to the state system to get the maximum value in the
210 * range. The test values are DOUBLE.
213 public void testQueryMipmapRangeMaxDouble() {
216 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
217 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 0, quark
));
218 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 500, 1500, quark
).unboxDouble(), DELTA
);
219 assertEquals(20.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 1500, 5000, quark
).unboxDouble(), DELTA
);
220 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 5000, 10000, quark
).unboxDouble(), DELTA
);
221 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 10000, quark
).unboxDouble(), DELTA
);
222 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqd
, 120000, 120000, quark
));
223 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 120500, 121500, quark
).unboxDouble(), DELTA
);
224 assertEquals(20.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 121500, 125000, quark
).unboxDouble(), DELTA
);
225 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 125000, 130000, quark
).unboxDouble(), DELTA
);
226 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 120000, 130000, quark
).unboxDouble(), DELTA
);
227 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 100000, 150000, quark
).unboxDouble(), DELTA
);
228 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 240000, 250000, quark
).unboxDouble(), DELTA
);
229 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 250000, quark
).unboxDouble(), DELTA
);
230 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 250000, 250000, quark
).unboxDouble(), DELTA
);
232 } catch (AttributeNotFoundException e
) {
233 fail(e
.getMessage());
234 } catch (StateValueTypeException e
) {
235 fail(e
.getMessage());
236 } catch (TimeRangeException e
) {
237 fail(e
.getMessage());
242 * Test a query range to the state system to get the minimum value in the
243 * range. The test values are DOUBLE.
246 public void testQueryMipmapRangeMinDouble() {
249 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
250 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 0, quark
));
251 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 500, 1500, quark
).unboxDouble(), DELTA
);
252 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 1500, 5000, quark
).unboxDouble(), DELTA
);
253 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 5000, 10000, quark
).unboxDouble(), DELTA
);
254 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 10000, quark
).unboxDouble(), DELTA
);
255 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqd
, 120000, 120000, quark
));
256 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 120500, 121500, quark
).unboxDouble(), DELTA
);
257 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 121500, 125000, quark
).unboxDouble(), DELTA
);
258 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 125000, 130000, quark
).unboxDouble(), DELTA
);
259 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 120000, 130000, quark
).unboxDouble(), DELTA
);
260 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 100000, 150000, quark
).unboxDouble(), DELTA
);
261 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 240000, 250000, quark
).unboxDouble(), DELTA
);
262 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 250000, quark
).unboxDouble(), DELTA
);
263 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 250000, 250000, quark
).unboxDouble(), DELTA
);
265 } catch (AttributeNotFoundException e
) {
266 fail(e
.getMessage());
267 } catch (StateValueTypeException e
) {
268 fail(e
.getMessage());
269 } catch (TimeRangeException e
) {
270 fail(e
.getMessage());
275 * Test a query range to the state system to get the average value in the
276 * range. The test values are DOUBLE.
279 public void testQueryMipmapRangeAvgDouble() {
282 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
283 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 0, quark
), DELTA
);
284 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 500, 1500, quark
), DELTA
);
285 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 1500, 5000, quark
), DELTA
);
286 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 5000, 10000, quark
), DELTA
);
287 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 10000, quark
), DELTA
);
288 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 20000, quark
), DELTA
);
289 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 500, 20500, quark
), DELTA
);
290 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 1000, 21000, quark
), DELTA
);
291 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 2000, 22000, quark
), DELTA
);
292 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 3000, 23000, quark
), DELTA
);
293 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 4000, 24000, quark
), DELTA
);
294 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 5000, 25000, quark
), DELTA
);
295 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120000, 120000, quark
), DELTA
);
296 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120500, 121500, quark
), DELTA
);
297 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 121500, 125000, quark
), DELTA
);
298 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 125000, 130000, quark
), DELTA
);
299 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120000, 130000, quark
), DELTA
);
300 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 100000, 150000, quark
), DELTA
);
301 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 240000, 250000, quark
), DELTA
);
302 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 250000, quark
), DELTA
);
303 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 250000, 250000, quark
), DELTA
);
305 } catch (AttributeNotFoundException e
) {
306 fail(e
.getMessage());
307 } catch (TimeRangeException e
) {
308 fail(e
.getMessage());
309 } catch (StateValueTypeException e
) {
310 fail(e
.getMessage());