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
.linuxtools
.statesystem
.core
.ITmfStateSystemBuilder
;
21 import org
.eclipse
.linuxtools
.statesystem
.core
.StateSystemFactory
;
22 import org
.eclipse
.linuxtools
.statesystem
.core
.backend
.IStateHistoryBackend
;
23 import org
.eclipse
.linuxtools
.statesystem
.core
.backend
.InMemoryBackend
;
24 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.AttributeNotFoundException
;
25 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.StateValueTypeException
;
26 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.TimeRangeException
;
27 import org
.eclipse
.linuxtools
.statesystem
.core
.statevalue
.ITmfStateValue
.Type
;
28 import org
.eclipse
.linuxtools
.statesystem
.core
.statevalue
.TmfStateValue
;
29 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.statesystem
.mipmap
.TmfStateSystemOperations
;
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 ssqi
= StateSystemFactory
.newStateSystem(SSID
, bei
);
57 mmpi
.assignTargetStateSystem(ssqi
);
58 /* setup for DOUBLE test */
59 TmfMipmapStateProviderStub mmpd
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.DOUBLE
);
60 IStateHistoryBackend bed
= new InMemoryBackend(0);
61 ssqd
= StateSystemFactory
.newStateSystem(SSID
, bed
);
62 mmpd
.assignTargetStateSystem(ssqd
);
64 * Every 10,000 ns chunk contains the following states:
66 * | null | 10 | null | 20 | null | 30 | null |
67 * 0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10,000
69 * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14.
71 for (int i
= 0; i
< END_TIME
/ INTERVAL
/ 10; i
++) {
72 long time
= i
* 10 * INTERVAL
;
73 /* update for INTEGER test */
74 mmpi
.processEvent(mmpi
.createEvent(time
, null));
75 mmpi
.processEvent(mmpi
.createEvent(time
+ 1000, 10L));
76 mmpi
.processEvent(mmpi
.createEvent(time
+ 2000, null));
77 mmpi
.processEvent(mmpi
.createEvent(time
+ 3000, 20L));
78 mmpi
.processEvent(mmpi
.createEvent(time
+ 5000, null));
79 mmpi
.processEvent(mmpi
.createEvent(time
+ 6000, 30L));
80 mmpi
.processEvent(mmpi
.createEvent(time
+ 9000, null));
81 /* update for DOUBLE test */
82 mmpd
.processEvent(mmpd
.createEvent(time
, null));
83 mmpd
.processEvent(mmpd
.createEvent(time
+ 1000, 10L));
84 mmpd
.processEvent(mmpd
.createEvent(time
+ 2000, null));
85 mmpd
.processEvent(mmpd
.createEvent(time
+ 3000, 20L));
86 mmpd
.processEvent(mmpd
.createEvent(time
+ 5000, null));
87 mmpd
.processEvent(mmpd
.createEvent(time
+ 6000, 30L));
88 mmpd
.processEvent(mmpd
.createEvent(time
+ 9000, null));
90 /* cleanup for INTEGER test */
91 mmpi
.processEvent(mmpi
.createEvent(END_TIME
, 0L));
93 ssqi
.waitUntilBuilt();
94 /* cleanup for DOUBLE test */
95 mmpd
.processEvent(mmpd
.createEvent(END_TIME
, 0L));
97 ssqd
.waitUntilBuilt();
101 * Test a query range to the state system to get the maximum value in the
102 * range. The test values are INTEGER.
105 public void testQueryMipmapRangeMaxInteger() {
108 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
109 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 0, quark
));
110 assertEquals(10, TmfStateSystemOperations
.queryRangeMax(ssqi
, 500, 1500, quark
).unboxInt());
111 assertEquals(20, TmfStateSystemOperations
.queryRangeMax(ssqi
, 1500, 5000, quark
).unboxInt());
112 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 5000, 10000, quark
).unboxInt());
113 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 10000, quark
).unboxInt());
114 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqi
, 120000, 120000, quark
));
115 assertEquals(10, TmfStateSystemOperations
.queryRangeMax(ssqi
, 120500, 121500, quark
).unboxInt());
116 assertEquals(20, TmfStateSystemOperations
.queryRangeMax(ssqi
, 121500, 125000, quark
).unboxInt());
117 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 125000, 130000, quark
).unboxInt());
118 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 120000, 130000, quark
).unboxInt());
119 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 100000, 150000, quark
).unboxInt());
120 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 240000, 250000, quark
).unboxInt());
121 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 250000, quark
).unboxInt());
122 assertEquals(00, TmfStateSystemOperations
.queryRangeMax(ssqi
, 250000, 250000, quark
).unboxInt());
124 } catch (AttributeNotFoundException e
) {
125 fail(e
.getMessage());
126 } catch (StateValueTypeException e
) {
127 fail(e
.getMessage());
128 } catch (TimeRangeException e
) {
129 fail(e
.getMessage());
134 * Test a query range to the state system to get the minimum value in the
135 * range. The test values are INTEGER.
138 public void testQueryMipmapRangeMinInteger() {
141 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
142 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 0, quark
));
143 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 500, 1500, quark
).unboxInt());
144 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 1500, 5000, quark
).unboxInt());
145 assertEquals(30, TmfStateSystemOperations
.queryRangeMin(ssqi
, 5000, 10000, quark
).unboxInt());
146 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 10000, quark
).unboxInt());
147 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqi
, 120000, 120000, quark
));
148 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 120500, 121500, quark
).unboxInt());
149 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 121500, 125000, quark
).unboxInt());
150 assertEquals(30, TmfStateSystemOperations
.queryRangeMin(ssqi
, 125000, 130000, quark
).unboxInt());
151 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 120000, 130000, quark
).unboxInt());
152 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 100000, 150000, quark
).unboxInt());
153 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 240000, 250000, quark
).unboxInt());
154 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 250000, quark
).unboxInt());
155 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 250000, 250000, quark
).unboxInt());
157 } catch (AttributeNotFoundException e
) {
158 fail(e
.getMessage());
159 } catch (StateValueTypeException e
) {
160 fail(e
.getMessage());
161 } catch (TimeRangeException e
) {
162 fail(e
.getMessage());
167 * Test a query range to the state system to get the average value in the
168 * range. The test values are INTEGER.
171 public void testQueryMipmapRangeAvgInteger() {
174 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
175 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 0, quark
), DELTA
);
176 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 500, 1500, quark
), DELTA
);
177 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 1500, 5000, quark
), DELTA
);
178 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 5000, 10000, quark
), DELTA
);
179 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 10000, quark
), DELTA
);
180 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 20000, quark
), DELTA
);
181 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 500, 20500, quark
), DELTA
);
182 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 1000, 21000, quark
), DELTA
);
183 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 2000, 22000, quark
), DELTA
);
184 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 3000, 23000, quark
), DELTA
);
185 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 4000, 24000, quark
), DELTA
);
186 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 5000, 25000, quark
), DELTA
);
187 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120000, 120000, quark
), DELTA
);
188 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120500, 121500, quark
), DELTA
);
189 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 121500, 125000, quark
), DELTA
);
190 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 125000, 130000, quark
), DELTA
);
191 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120000, 130000, quark
), DELTA
);
192 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 100000, 150000, quark
), DELTA
);
193 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 240000, 250000, quark
), DELTA
);
194 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 250000, quark
), DELTA
);
195 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 250000, 250000, quark
), DELTA
);
197 } catch (AttributeNotFoundException e
) {
198 fail(e
.getMessage());
199 } catch (TimeRangeException e
) {
200 fail(e
.getMessage());
201 } catch (StateValueTypeException e
) {
202 fail(e
.getMessage());
207 * Test a query range to the state system to get the maximum value in the
208 * range. The test values are DOUBLE.
211 public void testQueryMipmapRangeMaxDouble() {
214 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
215 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 0, quark
));
216 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 500, 1500, quark
).unboxDouble(), DELTA
);
217 assertEquals(20.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 1500, 5000, quark
).unboxDouble(), DELTA
);
218 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 5000, 10000, quark
).unboxDouble(), DELTA
);
219 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 10000, quark
).unboxDouble(), DELTA
);
220 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqd
, 120000, 120000, quark
));
221 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 120500, 121500, quark
).unboxDouble(), DELTA
);
222 assertEquals(20.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 121500, 125000, quark
).unboxDouble(), DELTA
);
223 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 125000, 130000, quark
).unboxDouble(), DELTA
);
224 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 120000, 130000, quark
).unboxDouble(), DELTA
);
225 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 100000, 150000, quark
).unboxDouble(), DELTA
);
226 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 240000, 250000, quark
).unboxDouble(), DELTA
);
227 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 250000, quark
).unboxDouble(), DELTA
);
228 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 250000, 250000, quark
).unboxDouble(), DELTA
);
230 } catch (AttributeNotFoundException e
) {
231 fail(e
.getMessage());
232 } catch (StateValueTypeException e
) {
233 fail(e
.getMessage());
234 } catch (TimeRangeException e
) {
235 fail(e
.getMessage());
240 * Test a query range to the state system to get the minimum value in the
241 * range. The test values are DOUBLE.
244 public void testQueryMipmapRangeMinDouble() {
247 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
248 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 0, quark
));
249 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 500, 1500, quark
).unboxDouble(), DELTA
);
250 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 1500, 5000, quark
).unboxDouble(), DELTA
);
251 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 5000, 10000, quark
).unboxDouble(), DELTA
);
252 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 10000, quark
).unboxDouble(), DELTA
);
253 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqd
, 120000, 120000, quark
));
254 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 120500, 121500, quark
).unboxDouble(), DELTA
);
255 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 121500, 125000, quark
).unboxDouble(), DELTA
);
256 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 125000, 130000, quark
).unboxDouble(), DELTA
);
257 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 120000, 130000, quark
).unboxDouble(), DELTA
);
258 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 100000, 150000, quark
).unboxDouble(), DELTA
);
259 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 240000, 250000, quark
).unboxDouble(), DELTA
);
260 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 250000, quark
).unboxDouble(), DELTA
);
261 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 250000, 250000, quark
).unboxDouble(), DELTA
);
263 } catch (AttributeNotFoundException e
) {
264 fail(e
.getMessage());
265 } catch (StateValueTypeException e
) {
266 fail(e
.getMessage());
267 } catch (TimeRangeException e
) {
268 fail(e
.getMessage());
273 * Test a query range to the state system to get the average value in the
274 * range. The test values are DOUBLE.
277 public void testQueryMipmapRangeAvgDouble() {
280 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
281 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 0, quark
), DELTA
);
282 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 500, 1500, quark
), DELTA
);
283 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 1500, 5000, quark
), DELTA
);
284 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 5000, 10000, quark
), DELTA
);
285 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 10000, quark
), DELTA
);
286 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 20000, quark
), DELTA
);
287 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 500, 20500, quark
), DELTA
);
288 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 1000, 21000, quark
), DELTA
);
289 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 2000, 22000, quark
), DELTA
);
290 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 3000, 23000, quark
), DELTA
);
291 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 4000, 24000, quark
), DELTA
);
292 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 5000, 25000, quark
), DELTA
);
293 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120000, 120000, quark
), DELTA
);
294 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120500, 121500, quark
), DELTA
);
295 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 121500, 125000, quark
), DELTA
);
296 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 125000, 130000, quark
), DELTA
);
297 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120000, 130000, quark
), DELTA
);
298 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 100000, 150000, quark
), DELTA
);
299 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 240000, 250000, quark
), DELTA
);
300 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 250000, quark
), DELTA
);
301 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 250000, 250000, quark
), DELTA
);
303 } catch (AttributeNotFoundException e
) {
304 fail(e
.getMessage());
305 } catch (TimeRangeException e
) {
306 fail(e
.getMessage());
307 } catch (StateValueTypeException e
) {
308 fail(e
.getMessage());