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
.linuxtools
.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
.internal
.tmf
.core
.statesystem
.StateSystem
;
21 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.statesystem
.backends
.IStateHistoryBackend
;
22 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.statesystem
.backends
.InMemoryBackend
;
23 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.AttributeNotFoundException
;
24 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.StateValueTypeException
;
25 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TimeRangeException
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.statesystem
.TmfStateSystemOperations
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.statevalue
.ITmfStateValue
.Type
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.statevalue
.TmfStateValue
;
29 import org
.junit
.BeforeClass
;
30 import org
.junit
.Test
;
33 * @author Patrick Tasse
36 public class TmfMipmapStateProviderWeightedTest
{
38 @NonNull private static final String SSID
= "mipmap-test";
39 private static final String TEST_ATTRIBUTE_NAME
= TmfMipmapStateProviderStub
.TEST_ATTRIBUTE_NAME
;
40 private static final long END_TIME
= 250000L;
41 private static final long INTERVAL
= 1000L;
42 private static final int RESOLUTION
= 2;
43 private static final double DELTA
= 0.0001;
44 private static StateSystem ssqi
;
45 private static StateSystem ssqd
;
48 * Startup code, build a state system with uneven state durations
51 public static void init() {
52 /* setup for INTEGER test */
53 TmfMipmapStateProviderStub mmpi
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.INTEGER
);
54 IStateHistoryBackend bei
= new InMemoryBackend(0);
55 ssqi
= new StateSystem(SSID
, bei
);
56 mmpi
.assignTargetStateSystem(ssqi
);
57 /* setup for DOUBLE test */
58 TmfMipmapStateProviderStub mmpd
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.DOUBLE
);
59 IStateHistoryBackend bed
= new InMemoryBackend(0);
60 ssqd
= new StateSystem(SSID
, bed
);
61 mmpd
.assignTargetStateSystem(ssqd
);
63 * Every 10,000 ns chunk contains the following states:
65 * | null | 10 | null | 20 | null | 30 | null |
66 * 0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10,000
68 * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14.
70 for (int i
= 0; i
< END_TIME
/ INTERVAL
/ 10; i
++) {
71 long time
= i
* 10 * INTERVAL
;
72 /* update for INTEGER test */
73 mmpi
.processEvent(mmpi
.createEvent(time
, null));
74 mmpi
.processEvent(mmpi
.createEvent(time
+ 1000, 10L));
75 mmpi
.processEvent(mmpi
.createEvent(time
+ 2000, null));
76 mmpi
.processEvent(mmpi
.createEvent(time
+ 3000, 20L));
77 mmpi
.processEvent(mmpi
.createEvent(time
+ 5000, null));
78 mmpi
.processEvent(mmpi
.createEvent(time
+ 6000, 30L));
79 mmpi
.processEvent(mmpi
.createEvent(time
+ 9000, null));
80 /* update for DOUBLE test */
81 mmpd
.processEvent(mmpd
.createEvent(time
, null));
82 mmpd
.processEvent(mmpd
.createEvent(time
+ 1000, 10L));
83 mmpd
.processEvent(mmpd
.createEvent(time
+ 2000, null));
84 mmpd
.processEvent(mmpd
.createEvent(time
+ 3000, 20L));
85 mmpd
.processEvent(mmpd
.createEvent(time
+ 5000, null));
86 mmpd
.processEvent(mmpd
.createEvent(time
+ 6000, 30L));
87 mmpd
.processEvent(mmpd
.createEvent(time
+ 9000, null));
89 /* cleanup for INTEGER test */
90 mmpi
.processEvent(mmpi
.createEvent(END_TIME
, 0L));
92 ssqi
.waitUntilBuilt();
93 /* cleanup for DOUBLE test */
94 mmpd
.processEvent(mmpd
.createEvent(END_TIME
, 0L));
96 ssqd
.waitUntilBuilt();
100 * Test a query range to the state system to get the maximum value in the
101 * range. The test values are INTEGER.
104 public void testQueryMipmapRangeMaxInteger() {
107 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
108 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 0, quark
));
109 assertEquals(10, TmfStateSystemOperations
.queryRangeMax(ssqi
, 500, 1500, quark
).unboxInt());
110 assertEquals(20, TmfStateSystemOperations
.queryRangeMax(ssqi
, 1500, 5000, quark
).unboxInt());
111 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 5000, 10000, quark
).unboxInt());
112 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 10000, quark
).unboxInt());
113 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqi
, 120000, 120000, quark
));
114 assertEquals(10, TmfStateSystemOperations
.queryRangeMax(ssqi
, 120500, 121500, quark
).unboxInt());
115 assertEquals(20, TmfStateSystemOperations
.queryRangeMax(ssqi
, 121500, 125000, quark
).unboxInt());
116 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 125000, 130000, quark
).unboxInt());
117 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 120000, 130000, quark
).unboxInt());
118 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 100000, 150000, quark
).unboxInt());
119 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 240000, 250000, quark
).unboxInt());
120 assertEquals(30, TmfStateSystemOperations
.queryRangeMax(ssqi
, 0, 250000, quark
).unboxInt());
121 assertEquals(00, TmfStateSystemOperations
.queryRangeMax(ssqi
, 250000, 250000, quark
).unboxInt());
123 } catch (AttributeNotFoundException e
) {
124 fail(e
.getMessage());
125 } catch (StateValueTypeException e
) {
126 fail(e
.getMessage());
127 } catch (TimeRangeException e
) {
128 fail(e
.getMessage());
133 * Test a query range to the state system to get the minimum value in the
134 * range. The test values are INTEGER.
137 public void testQueryMipmapRangeMinInteger() {
140 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
141 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 0, quark
));
142 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 500, 1500, quark
).unboxInt());
143 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 1500, 5000, quark
).unboxInt());
144 assertEquals(30, TmfStateSystemOperations
.queryRangeMin(ssqi
, 5000, 10000, quark
).unboxInt());
145 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 10000, quark
).unboxInt());
146 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqi
, 120000, 120000, quark
));
147 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 120500, 121500, quark
).unboxInt());
148 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 121500, 125000, quark
).unboxInt());
149 assertEquals(30, TmfStateSystemOperations
.queryRangeMin(ssqi
, 125000, 130000, quark
).unboxInt());
150 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 120000, 130000, quark
).unboxInt());
151 assertEquals(10, TmfStateSystemOperations
.queryRangeMin(ssqi
, 100000, 150000, quark
).unboxInt());
152 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 240000, 250000, quark
).unboxInt());
153 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 0, 250000, quark
).unboxInt());
154 assertEquals(00, TmfStateSystemOperations
.queryRangeMin(ssqi
, 250000, 250000, quark
).unboxInt());
156 } catch (AttributeNotFoundException e
) {
157 fail(e
.getMessage());
158 } catch (StateValueTypeException e
) {
159 fail(e
.getMessage());
160 } catch (TimeRangeException e
) {
161 fail(e
.getMessage());
166 * Test a query range to the state system to get the average value in the
167 * range. The test values are INTEGER.
170 public void testQueryMipmapRangeAvgInteger() {
173 int quark
= ssqi
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
174 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 0, quark
), DELTA
);
175 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 500, 1500, quark
), DELTA
);
176 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 1500, 5000, quark
), DELTA
);
177 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 5000, 10000, quark
), DELTA
);
178 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 10000, quark
), DELTA
);
179 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 20000, quark
), DELTA
);
180 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 500, 20500, quark
), DELTA
);
181 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 1000, 21000, quark
), DELTA
);
182 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 2000, 22000, quark
), DELTA
);
183 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 3000, 23000, quark
), DELTA
);
184 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 4000, 24000, quark
), DELTA
);
185 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 5000, 25000, quark
), DELTA
);
186 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120000, 120000, quark
), DELTA
);
187 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120500, 121500, quark
), DELTA
);
188 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 121500, 125000, quark
), DELTA
);
189 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 125000, 130000, quark
), DELTA
);
190 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 120000, 130000, quark
), DELTA
);
191 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 100000, 150000, quark
), DELTA
);
192 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 240000, 250000, quark
), DELTA
);
193 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 0, 250000, quark
), DELTA
);
194 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqi
, 250000, 250000, quark
), DELTA
);
196 } catch (AttributeNotFoundException e
) {
197 fail(e
.getMessage());
198 } catch (TimeRangeException e
) {
199 fail(e
.getMessage());
200 } catch (StateValueTypeException e
) {
201 fail(e
.getMessage());
206 * Test a query range to the state system to get the maximum value in the
207 * range. The test values are DOUBLE.
210 public void testQueryMipmapRangeMaxDouble() {
213 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
214 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 0, quark
));
215 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 500, 1500, quark
).unboxDouble(), DELTA
);
216 assertEquals(20.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 1500, 5000, quark
).unboxDouble(), DELTA
);
217 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 5000, 10000, quark
).unboxDouble(), DELTA
);
218 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 10000, quark
).unboxDouble(), DELTA
);
219 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMax(ssqd
, 120000, 120000, quark
));
220 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 120500, 121500, quark
).unboxDouble(), DELTA
);
221 assertEquals(20.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 121500, 125000, quark
).unboxDouble(), DELTA
);
222 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 125000, 130000, quark
).unboxDouble(), DELTA
);
223 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 120000, 130000, quark
).unboxDouble(), DELTA
);
224 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 100000, 150000, quark
).unboxDouble(), DELTA
);
225 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 240000, 250000, quark
).unboxDouble(), DELTA
);
226 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 0, 250000, quark
).unboxDouble(), DELTA
);
227 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMax(ssqd
, 250000, 250000, quark
).unboxDouble(), DELTA
);
229 } catch (AttributeNotFoundException e
) {
230 fail(e
.getMessage());
231 } catch (StateValueTypeException e
) {
232 fail(e
.getMessage());
233 } catch (TimeRangeException e
) {
234 fail(e
.getMessage());
239 * Test a query range to the state system to get the minimum value in the
240 * range. The test values are DOUBLE.
243 public void testQueryMipmapRangeMinDouble() {
246 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
247 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 0, quark
));
248 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 500, 1500, quark
).unboxDouble(), DELTA
);
249 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 1500, 5000, quark
).unboxDouble(), DELTA
);
250 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 5000, 10000, quark
).unboxDouble(), DELTA
);
251 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 10000, quark
).unboxDouble(), DELTA
);
252 assertEquals(TmfStateValue
.nullValue(), TmfStateSystemOperations
.queryRangeMin(ssqd
, 120000, 120000, quark
));
253 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 120500, 121500, quark
).unboxDouble(), DELTA
);
254 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 121500, 125000, quark
).unboxDouble(), DELTA
);
255 assertEquals(30.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 125000, 130000, quark
).unboxDouble(), DELTA
);
256 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 120000, 130000, quark
).unboxDouble(), DELTA
);
257 assertEquals(10.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 100000, 150000, quark
).unboxDouble(), DELTA
);
258 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 240000, 250000, quark
).unboxDouble(), DELTA
);
259 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 0, 250000, quark
).unboxDouble(), DELTA
);
260 assertEquals(00.0, TmfStateSystemOperations
.queryRangeMin(ssqd
, 250000, 250000, quark
).unboxDouble(), DELTA
);
262 } catch (AttributeNotFoundException e
) {
263 fail(e
.getMessage());
264 } catch (StateValueTypeException e
) {
265 fail(e
.getMessage());
266 } catch (TimeRangeException e
) {
267 fail(e
.getMessage());
272 * Test a query range to the state system to get the average value in the
273 * range. The test values are DOUBLE.
276 public void testQueryMipmapRangeAvgDouble() {
279 int quark
= ssqd
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
280 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 0, quark
), DELTA
);
281 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 500, 1500, quark
), DELTA
);
282 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 1500, 5000, quark
), DELTA
);
283 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 5000, 10000, quark
), DELTA
);
284 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 10000, quark
), DELTA
);
285 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 20000, quark
), DELTA
);
286 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 500, 20500, quark
), DELTA
);
287 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 1000, 21000, quark
), DELTA
);
288 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 2000, 22000, quark
), DELTA
);
289 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 3000, 23000, quark
), DELTA
);
290 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 4000, 24000, quark
), DELTA
);
291 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 5000, 25000, quark
), DELTA
);
292 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120000, 120000, quark
), DELTA
);
293 assertEquals(5.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120500, 121500, quark
), DELTA
);
294 assertEquals(90.0 / 7, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 121500, 125000, quark
), DELTA
);
295 assertEquals(90.0 / 5, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 125000, 130000, quark
), DELTA
);
296 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 120000, 130000, quark
), DELTA
);
297 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 100000, 150000, quark
), DELTA
);
298 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 240000, 250000, quark
), DELTA
);
299 assertEquals(14.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 0, 250000, quark
), DELTA
);
300 assertEquals(0.0, TmfStateSystemOperations
.queryRangeAverage(ssqd
, 250000, 250000, quark
), DELTA
);
302 } catch (AttributeNotFoundException e
) {
303 fail(e
.getMessage());
304 } catch (TimeRangeException e
) {
305 fail(e
.getMessage());
306 } catch (StateValueTypeException e
) {
307 fail(e
.getMessage());