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