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); | |
bcec0116 | 56 | ssqi = StateSystemFactory.newStateSystem(SSID, bei); |
8e364f8e PT |
57 | mmpi.assignTargetStateSystem(ssqi); |
58 | /* setup for DOUBLE test */ | |
59 | TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE); | |
60 | IStateHistoryBackend bed = new InMemoryBackend(0); | |
bcec0116 | 61 | ssqd = StateSystemFactory.newStateSystem(SSID, bed); |
8e364f8e PT |
62 | mmpd.assignTargetStateSystem(ssqd); |
63 | /* | |
64 | * Every 10,000 ns chunk contains the following states: | |
65 | * | |
66 | * | null | 10 | null | 20 | null | 30 | null | | |
67 | * 0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10,000 | |
68 | * | |
69 | * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14. | |
70 | */ | |
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)); | |
89 | } | |
90 | /* cleanup for INTEGER test */ | |
91 | mmpi.processEvent(mmpi.createEvent(END_TIME, 0L)); | |
92 | mmpi.dispose(); | |
93 | ssqi.waitUntilBuilt(); | |
94 | /* cleanup for DOUBLE test */ | |
95 | mmpd.processEvent(mmpd.createEvent(END_TIME, 0L)); | |
96 | mmpd.dispose(); | |
97 | ssqd.waitUntilBuilt(); | |
98 | } | |
99 | ||
100 | /** | |
101 | * Test a query range to the state system to get the maximum value in the | |
102 | * range. The test values are INTEGER. | |
103 | */ | |
104 | @Test | |
105 | public void testQueryMipmapRangeMaxInteger() { | |
106 | assertNotNull(ssqi); | |
107 | try { | |
108 | int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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()); | |
123 | ||
8e364f8e PT |
124 | } catch (AttributeNotFoundException e) { |
125 | fail(e.getMessage()); | |
126 | } catch (StateValueTypeException e) { | |
127 | fail(e.getMessage()); | |
64d15677 AM |
128 | } catch (TimeRangeException e) { |
129 | fail(e.getMessage()); | |
8e364f8e PT |
130 | } |
131 | } | |
132 | ||
133 | /** | |
134 | * Test a query range to the state system to get the minimum value in the | |
135 | * range. The test values are INTEGER. | |
136 | */ | |
137 | @Test | |
138 | public void testQueryMipmapRangeMinInteger() { | |
139 | assertNotNull(ssqi); | |
140 | try { | |
141 | int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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()); | |
156 | ||
8e364f8e PT |
157 | } catch (AttributeNotFoundException e) { |
158 | fail(e.getMessage()); | |
159 | } catch (StateValueTypeException e) { | |
160 | fail(e.getMessage()); | |
64d15677 AM |
161 | } catch (TimeRangeException e) { |
162 | fail(e.getMessage()); | |
8e364f8e PT |
163 | } |
164 | } | |
165 | ||
166 | /** | |
167 | * Test a query range to the state system to get the average value in the | |
168 | * range. The test values are INTEGER. | |
169 | */ | |
170 | @Test | |
171 | public void testQueryMipmapRangeAvgInteger() { | |
172 | assertNotNull(ssqi); | |
173 | try { | |
174 | int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
196 | ||
8e364f8e PT |
197 | } catch (AttributeNotFoundException e) { |
198 | fail(e.getMessage()); | |
64d15677 AM |
199 | } catch (TimeRangeException e) { |
200 | fail(e.getMessage()); | |
201 | } catch (StateValueTypeException e) { | |
202 | fail(e.getMessage()); | |
8e364f8e PT |
203 | } |
204 | } | |
205 | ||
206 | /** | |
207 | * Test a query range to the state system to get the maximum value in the | |
208 | * range. The test values are DOUBLE. | |
209 | */ | |
210 | @Test | |
211 | public void testQueryMipmapRangeMaxDouble() { | |
212 | assertNotNull(ssqd); | |
213 | try { | |
214 | int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
229 | ||
8e364f8e PT |
230 | } catch (AttributeNotFoundException e) { |
231 | fail(e.getMessage()); | |
232 | } catch (StateValueTypeException e) { | |
233 | fail(e.getMessage()); | |
64d15677 AM |
234 | } catch (TimeRangeException e) { |
235 | fail(e.getMessage()); | |
8e364f8e PT |
236 | } |
237 | } | |
238 | ||
239 | /** | |
240 | * Test a query range to the state system to get the minimum value in the | |
241 | * range. The test values are DOUBLE. | |
242 | */ | |
243 | @Test | |
244 | public void testQueryMipmapRangeMinDouble() { | |
245 | assertNotNull(ssqd); | |
246 | try { | |
247 | int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
262 | ||
8e364f8e PT |
263 | } catch (AttributeNotFoundException e) { |
264 | fail(e.getMessage()); | |
265 | } catch (StateValueTypeException e) { | |
266 | fail(e.getMessage()); | |
64d15677 AM |
267 | } catch (TimeRangeException e) { |
268 | fail(e.getMessage()); | |
8e364f8e PT |
269 | } |
270 | } | |
271 | ||
272 | /** | |
273 | * Test a query range to the state system to get the average value in the | |
274 | * range. The test values are DOUBLE. | |
275 | */ | |
276 | @Test | |
277 | public void testQueryMipmapRangeAvgDouble() { | |
278 | assertNotNull(ssqd); | |
279 | try { | |
280 | int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); | |
64d15677 AM |
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); | |
302 | ||
8e364f8e PT |
303 | } catch (AttributeNotFoundException e) { |
304 | fail(e.getMessage()); | |
64d15677 AM |
305 | } catch (TimeRangeException e) { |
306 | fail(e.getMessage()); | |
307 | } catch (StateValueTypeException e) { | |
308 | fail(e.getMessage()); | |
8e364f8e PT |
309 | } |
310 | } | |
311 | } |