Commit | Line | Data |
---|---|---|
8e364f8e | 1 | /******************************************************************************* |
60ae41e1 | 2 | * Copyright (c) 2013, 2014 Ericsson |
8e364f8e PT |
3 | * |
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 | |
8 | * | |
9 | * Contributors: | |
10 | * Patrick Tasse - Updates to mipmap feature | |
11 | *******************************************************************************/ | |
12 | ||
2bdf0193 | 13 | package org.eclipse.tracecompass.tmf.core.tests.statesystem.mipmap; |
8e364f8e PT |
14 | |
15 | import static org.junit.Assert.assertEquals; | |
16 | import static org.junit.Assert.assertNotNull; | |
17 | import static org.junit.Assert.fail; | |
18 | ||
84a9548a | 19 | import org.eclipse.jdt.annotation.NonNull; |
2bdf0193 | 20 | import org.eclipse.tracecompass.internal.tmf.core.statesystem.mipmap.TmfStateSystemOperations; |
e894a508 AM |
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; | |
8e364f8e PT |
30 | import org.junit.BeforeClass; |
31 | import org.junit.Test; | |
32 | ||
33 | /** | |
34 | * @author Patrick Tasse | |
35 | * | |
36 | */ | |
37 | public class TmfMipmapStateProviderWeightedTest { | |
84a9548a AM |
38 | |
39 | @NonNull private static final String SSID = "mipmap-test"; | |
8e364f8e PT |
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; | |
bcec0116 AM |
45 | private static ITmfStateSystemBuilder ssqi; |
46 | private static ITmfStateSystemBuilder ssqd; | |
8e364f8e PT |
47 | |
48 | /** | |
49 | * Startup code, build a state system with uneven state durations | |
50 | */ | |
51 | @BeforeClass | |
52 | public static void init() { | |
53 | /* setup for INTEGER test */ | |
54 | TmfMipmapStateProviderStub mmpi = new TmfMipmapStateProviderStub(RESOLUTION, Type.INTEGER); | |
55 | IStateHistoryBackend bei = new InMemoryBackend(0); | |
d0c7e4ba AM |
56 | ITmfStateSystemBuilder ssbi = StateSystemFactory.newStateSystem(SSID, bei); |
57 | mmpi.assignTargetStateSystem(ssbi); | |
58 | ssqi = ssbi; | |
8e364f8e PT |
59 | /* setup for DOUBLE test */ |
60 | TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE); | |
61 | IStateHistoryBackend bed = new InMemoryBackend(0); | |
d0c7e4ba AM |
62 | ITmfStateSystemBuilder ssbd = StateSystemFactory.newStateSystem(SSID, bed); |
63 | mmpd.assignTargetStateSystem(ssbd); | |
64 | ssqd = ssbd; | |
8e364f8e PT |
65 | /* |
66 | * Every 10,000 ns chunk contains the following states: | |
67 | * | |
68 | * | null | 10 | null | 20 | null | 30 | null | | |
69 | * 0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10,000 | |
70 | * | |
71 | * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14. | |
72 | */ | |
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)); | |
91 | } | |
92 | /* cleanup for INTEGER test */ | |
93 | mmpi.processEvent(mmpi.createEvent(END_TIME, 0L)); | |
94 | mmpi.dispose(); | |
95 | ssqi.waitUntilBuilt(); | |
96 | /* cleanup for DOUBLE test */ | |
97 | mmpd.processEvent(mmpd.createEvent(END_TIME, 0L)); | |
98 | mmpd.dispose(); | |
99 | ssqd.waitUntilBuilt(); | |
100 | } | |
101 | ||
102 | /** | |
103 | * Test a query range to the state system to get the maximum value in the | |
104 | * range. The test values are INTEGER. | |
105 | */ | |
106 | @Test | |
107 | public void testQueryMipmapRangeMaxInteger() { | |
108 | assertNotNull(ssqi); | |
109 | try { | |
110 | int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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()); | |
125 | ||
8e364f8e PT |
126 | } catch (AttributeNotFoundException e) { |
127 | fail(e.getMessage()); | |
128 | } catch (StateValueTypeException e) { | |
129 | fail(e.getMessage()); | |
64d15677 AM |
130 | } catch (TimeRangeException e) { |
131 | fail(e.getMessage()); | |
8e364f8e PT |
132 | } |
133 | } | |
134 | ||
135 | /** | |
136 | * Test a query range to the state system to get the minimum value in the | |
137 | * range. The test values are INTEGER. | |
138 | */ | |
139 | @Test | |
140 | public void testQueryMipmapRangeMinInteger() { | |
141 | assertNotNull(ssqi); | |
142 | try { | |
143 | int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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()); | |
158 | ||
8e364f8e PT |
159 | } catch (AttributeNotFoundException e) { |
160 | fail(e.getMessage()); | |
161 | } catch (StateValueTypeException e) { | |
162 | fail(e.getMessage()); | |
64d15677 AM |
163 | } catch (TimeRangeException e) { |
164 | fail(e.getMessage()); | |
8e364f8e PT |
165 | } |
166 | } | |
167 | ||
168 | /** | |
169 | * Test a query range to the state system to get the average value in the | |
170 | * range. The test values are INTEGER. | |
171 | */ | |
172 | @Test | |
173 | public void testQueryMipmapRangeAvgInteger() { | |
174 | assertNotNull(ssqi); | |
175 | try { | |
176 | int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
198 | ||
8e364f8e PT |
199 | } catch (AttributeNotFoundException e) { |
200 | fail(e.getMessage()); | |
64d15677 AM |
201 | } catch (TimeRangeException e) { |
202 | fail(e.getMessage()); | |
203 | } catch (StateValueTypeException e) { | |
204 | fail(e.getMessage()); | |
8e364f8e PT |
205 | } |
206 | } | |
207 | ||
208 | /** | |
209 | * Test a query range to the state system to get the maximum value in the | |
210 | * range. The test values are DOUBLE. | |
211 | */ | |
212 | @Test | |
213 | public void testQueryMipmapRangeMaxDouble() { | |
214 | assertNotNull(ssqd); | |
215 | try { | |
216 | int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
231 | ||
8e364f8e PT |
232 | } catch (AttributeNotFoundException e) { |
233 | fail(e.getMessage()); | |
234 | } catch (StateValueTypeException e) { | |
235 | fail(e.getMessage()); | |
64d15677 AM |
236 | } catch (TimeRangeException e) { |
237 | fail(e.getMessage()); | |
8e364f8e PT |
238 | } |
239 | } | |
240 | ||
241 | /** | |
242 | * Test a query range to the state system to get the minimum value in the | |
243 | * range. The test values are DOUBLE. | |
244 | */ | |
245 | @Test | |
246 | public void testQueryMipmapRangeMinDouble() { | |
247 | assertNotNull(ssqd); | |
248 | try { | |
249 | int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
264 | ||
8e364f8e PT |
265 | } catch (AttributeNotFoundException e) { |
266 | fail(e.getMessage()); | |
267 | } catch (StateValueTypeException e) { | |
268 | fail(e.getMessage()); | |
64d15677 AM |
269 | } catch (TimeRangeException e) { |
270 | fail(e.getMessage()); | |
8e364f8e PT |
271 | } |
272 | } | |
273 | ||
274 | /** | |
275 | * Test a query range to the state system to get the average value in the | |
276 | * range. The test values are DOUBLE. | |
277 | */ | |
278 | @Test | |
279 | public void testQueryMipmapRangeAvgDouble() { | |
280 | assertNotNull(ssqd); | |
281 | try { | |
282 | int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
304 | ||
8e364f8e PT |
305 | } catch (AttributeNotFoundException e) { |
306 | fail(e.getMessage()); | |
64d15677 AM |
307 | } catch (TimeRangeException e) { |
308 | fail(e.getMessage()); | |
309 | } catch (StateValueTypeException e) { | |
310 | fail(e.getMessage()); | |
8e364f8e PT |
311 | } |
312 | } | |
313 | } |