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 * Jean-Christian Kouamé - Initial API and implementation
11 * Patrick Tasse - Updates to mipmap feature
12 *******************************************************************************/
14 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.statesystem
.mipmap
;
16 import static org
.junit
.Assert
.assertEquals
;
17 import static org
.junit
.Assert
.assertNotNull
;
18 import static org
.junit
.Assert
.assertTrue
;
19 import static org
.junit
.Assert
.fail
;
21 import java
.util
.List
;
22 import java
.util
.Random
;
24 import org
.eclipse
.jdt
.annotation
.NonNull
;
25 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.statesystem
.mipmap
.AbstractTmfMipmapStateProvider
;
26 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.statesystem
.mipmap
.TmfStateSystemOperations
;
27 import org
.eclipse
.tracecompass
.statesystem
.core
.ITmfStateSystemBuilder
;
28 import org
.eclipse
.tracecompass
.statesystem
.core
.StateSystemFactory
;
29 import org
.eclipse
.tracecompass
.statesystem
.core
.backend
.IStateHistoryBackend
;
30 import org
.eclipse
.tracecompass
.statesystem
.core
.backend
.InMemoryBackend
;
31 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.AttributeNotFoundException
;
32 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.StateSystemDisposedException
;
33 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.StateValueTypeException
;
34 import org
.eclipse
.tracecompass
.statesystem
.core
.exceptions
.TimeRangeException
;
35 import org
.eclipse
.tracecompass
.statesystem
.core
.interval
.ITmfStateInterval
;
36 import org
.eclipse
.tracecompass
.statesystem
.core
.statevalue
.ITmfStateValue
.Type
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEvent
;
38 import org
.junit
.BeforeClass
;
39 import org
.junit
.Test
;
42 * @author Jean-Christian Kouamé
45 public class TmfMipmapStateProviderTest
{
47 @NonNull private static final String SSID
= "mimap-test";
48 private static final String TEST_ATTRIBUTE_NAME
= TmfMipmapStateProviderStub
.TEST_ATTRIBUTE_NAME
;
49 private static final int NB_LEVELS
= 4;
50 private static final long START_TIME
= 1000L;
51 private static final long END_TIME
= 100000000L;
52 private static final long INTERVAL
= 1000L;
53 private static final int RESOLUTION
= 16;
54 private static final double DELTA
= 0.0001;
55 private static final long TEST_TIMESTAMP
= 12345000L;
56 private static ITmfStateSystemBuilder ssq
;
59 * Startup code, build a state system with n attributes always going up
63 public static void init() {
64 TmfMipmapStateProviderStub mmp
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.LONG
);
65 IStateHistoryBackend be
= new InMemoryBackend(0);
66 ITmfStateSystemBuilder ssb
= StateSystemFactory
.newStateSystem(SSID
, be
);
67 mmp
.assignTargetStateSystem(ssb
);
70 for (long time
= START_TIME
; time
<= END_TIME
; time
+= INTERVAL
) {
71 long value
= time
/ INTERVAL
;
72 ITmfEvent event
= mmp
.createEvent(time
, value
);
73 mmp
.processEvent(event
);
80 * Test a single query to the state system.
82 * Make sure the state system has data.
84 * Hint: the value read should always be t / 1000
88 public void testQuery() {
91 Random rn
= new Random();
92 long time
= Math
.max(INTERVAL
, rn
.nextLong() % END_TIME
);
93 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(time
);
94 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
95 ITmfStateInterval interval
= intervals
.get(mipmapQuark
);
96 long valueLong
= interval
.getStateValue().unboxLong();
97 assertEquals(time
/ INTERVAL
, valueLong
);
99 } catch (TimeRangeException e
) {
100 fail(e
.getMessage());
101 } catch (StateSystemDisposedException e
) {
102 fail(e
.getMessage());
103 } catch (AttributeNotFoundException e
) {
104 fail(e
.getMessage());
105 } catch (StateValueTypeException e
) {
106 fail(e
.getMessage());
112 * Test a single query to the state system for the maxLevel.
114 * Make sure the state system has data.
118 public void testMaxLevel() {
121 Random rn
= new Random();
122 long time
= Math
.max(INTERVAL
, rn
.nextLong() % END_TIME
);
123 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(time
);
125 int maxMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
126 int nbLevelMax
= intervals
.get(maxMipmapQuark
).getStateValue().unboxInt();
127 assertEquals(NB_LEVELS
, nbLevelMax
);
129 int minMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
130 int nbLevelMin
= intervals
.get(minMipmapQuark
).getStateValue().unboxInt();
131 assertEquals(NB_LEVELS
, nbLevelMin
);
133 int avgMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
134 int nbLevelAvg
= intervals
.get(avgMipmapQuark
).getStateValue().unboxInt();
135 assertEquals(NB_LEVELS
, nbLevelAvg
);
137 } catch (TimeRangeException e
) {
138 fail(e
.getMessage());
139 } catch (StateSystemDisposedException e
) {
140 fail(e
.getMessage());
141 } catch (AttributeNotFoundException e
) {
142 fail(e
.getMessage());
143 } catch (StateValueTypeException e
) {
144 fail(e
.getMessage());
151 * Test a single query to the state system for a mip
153 * Make sure the state system has data.
157 public void testQueryEventField() {
160 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
161 int eventFieldQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
162 ITmfStateInterval interval
= intervals
.get(eventFieldQuark
);
163 long valueLong
= interval
.getStateValue().unboxLong();
164 assertEquals(TEST_TIMESTAMP
/ INTERVAL
, valueLong
);
165 } catch (TimeRangeException e
) {
166 fail(e
.getMessage());
167 } catch (StateSystemDisposedException e
) {
168 fail(e
.getMessage());
169 } catch (AttributeNotFoundException e
) {
170 fail(e
.getMessage());
171 } catch (StateValueTypeException e
) {
172 fail(e
.getMessage());
178 * Test a single query to the state system for a max
180 * Make sure the state system has data.
182 * Hint: the value read should always be greater than(t / 1000)
186 public void testQueryMipMax() {
189 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
190 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
192 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
193 for (int level
= 1; level
< NB_LEVELS
; level
++) {
194 long width
= (long) Math
.pow(RESOLUTION
, level
);
195 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
196 ITmfStateInterval interval
= intervals
.get(levelQuark
);
197 long valueLong
= interval
.getStateValue().unboxLong();
198 assertEquals("max value @ level " + level
, width
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueLong
);
199 assertEquals("max start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
200 assertEquals("max end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
203 } catch (TimeRangeException e
) {
204 fail(e
.getMessage());
205 } catch (StateSystemDisposedException e
) {
206 fail(e
.getMessage());
207 } catch (AttributeNotFoundException e
) {
208 fail(e
.getMessage());
209 } catch (StateValueTypeException e
) {
210 fail(e
.getMessage());
216 * Test a single query to the state system for a min
218 * Make sure the state system has data.
220 * Hint: the value read should always be less than(t / 1000)
223 public void testQueryMipMin() {
226 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
227 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
229 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
230 for (int level
= 1; level
< NB_LEVELS
; level
++) {
231 long width
= (long) Math
.pow(RESOLUTION
, level
);
232 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
233 ITmfStateInterval interval
= intervals
.get(levelQuark
);
234 long valueLong
= interval
.getStateValue().unboxLong();
235 assertEquals("min value @ level " + level
, 1 + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueLong
);
236 assertEquals("min start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
237 assertEquals("min end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
240 } catch (TimeRangeException e
) {
241 fail(e
.getMessage());
242 } catch (StateSystemDisposedException e
) {
243 fail(e
.getMessage());
244 } catch (AttributeNotFoundException e
) {
245 fail(e
.getMessage());
246 } catch (StateValueTypeException e
) {
247 fail(e
.getMessage());
253 * Test a single query to the state system for an average
255 * Make sure the state system has data.
257 * Hint: the value read should always be more or less(t / 1000)
261 public void testQueryMipAvg() {
264 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
265 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
267 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
268 for (int level
= 1; level
< NB_LEVELS
; level
++) {
269 long width
= (long) Math
.pow(RESOLUTION
, level
);
270 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
271 ITmfStateInterval interval
= intervals
.get(levelQuark
);
272 double valueDouble
= interval
.getStateValue().unboxDouble();
273 assertEquals("avg value @ level " + level
, 0.5 + (width
/ 2) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueDouble
, DELTA
);
274 assertEquals("avg start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
275 assertEquals("avg end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
278 } catch (TimeRangeException e
) {
279 fail(e
.getMessage());
280 } catch (StateSystemDisposedException e
) {
281 fail(e
.getMessage());
282 } catch (AttributeNotFoundException e
) {
283 fail(e
.getMessage());
284 } catch (StateValueTypeException e
) {
285 fail(e
.getMessage());
291 * Test a full query to the state system at the startTime
293 * Make sure the state system has data.
295 * Hint: the value read should always be more or less(t / 1000)
299 public void testQueryValuesOnStart() {
304 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(START_TIME
);
306 int baseQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
307 assertEquals(START_TIME
/ INTERVAL
, intervals
.get(baseQuark
).getStateValue().unboxLong());
309 int maxMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
310 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(maxMipmapQuark
).getStateValue().unboxInt());
311 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(1));
312 assertEquals("max value @ level 1", (long) Math
.pow(RESOLUTION
, 1), intervals
.get(quark
).getStateValue().unboxLong());
313 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(2));
314 assertEquals("max value @ level 2", (long) Math
.pow(RESOLUTION
, 2), intervals
.get(quark
).getStateValue().unboxLong());
315 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(3));
316 assertEquals("max value @ level 3", (long) Math
.pow(RESOLUTION
, 3), intervals
.get(quark
).getStateValue().unboxLong());
317 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(4));
318 assertEquals("max value @ level 4", (long) Math
.pow(RESOLUTION
, 4), intervals
.get(quark
).getStateValue().unboxLong());
320 int minMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
321 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(minMipmapQuark
).getStateValue().unboxInt());
322 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(1));
323 assertEquals("min value @ level 1", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
324 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(2));
325 assertEquals("min value @ level 2", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
326 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(3));
327 assertEquals("min value @ level 3", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
328 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(4));
329 assertEquals("min value @ level 4", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
331 int avgMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
332 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(avgMipmapQuark
).getStateValue().unboxInt());
333 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(1));
334 assertEquals("avg value @ level 1", 0.5 + Math
.pow(RESOLUTION
, 1) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
335 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(2));
336 assertEquals("avg value @ level 2", 0.5 + Math
.pow(RESOLUTION
, 2) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
337 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(3));
338 assertEquals("avg value @ level 3", 0.5 + Math
.pow(RESOLUTION
, 3) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
339 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(4));
340 assertEquals("avg value @ level 4", 0.5 + Math
.pow(RESOLUTION
, 4) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
342 } catch (TimeRangeException e
) {
343 fail(e
.getMessage());
344 } catch (StateSystemDisposedException e
) {
345 fail(e
.getMessage());
346 } catch (AttributeNotFoundException e
) {
347 fail(e
.getMessage());
348 } catch (StateValueTypeException e
) {
349 fail(e
.getMessage());
355 * Test a full query to the state system when the end time
357 * Make sure the state system has data.
359 * Hint: the value read should always be more or less(t / 1000)
363 public void testQueryValuesOnClose() {
368 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(END_TIME
);
370 int baseQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
371 assertEquals(END_TIME
/ INTERVAL
, intervals
.get(baseQuark
).getStateValue().unboxLong());
373 int maxMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
374 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(maxMipmapQuark
).getStateValue().unboxInt());
375 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(1));
376 assertEquals("max value @ level 1", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
377 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(2));
378 assertEquals("max value @ level 2", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
379 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(3));
380 assertEquals("max value @ level 3", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
381 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(4));
382 assertEquals("max value @ level 4", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
384 int minMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
385 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(minMipmapQuark
).getStateValue().unboxInt());
386 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(1));
387 assertEquals("min value @ level 1", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 1), intervals
.get(quark
).getStateValue().unboxLong());
388 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(2));
389 assertEquals("min value @ level 2", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 2), intervals
.get(quark
).getStateValue().unboxLong());
390 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(3));
391 assertEquals("min value @ level 3", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 3), intervals
.get(quark
).getStateValue().unboxLong());
392 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(4));
393 assertEquals("min value @ level 4", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 4), intervals
.get(quark
).getStateValue().unboxLong());
395 int avgMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
396 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(avgMipmapQuark
).getStateValue().unboxInt());
397 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(1));
398 assertEquals("avg value @ level 1", (long) (END_TIME
/ INTERVAL
- (double) ((END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 1)) / 2), intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
399 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(2));
400 assertEquals("avg value @ level 2", (long) (END_TIME
/ INTERVAL
- (double) ((END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 2)) / 2), intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
401 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(3));
402 assertEquals("avg value @ level 3", (long) (END_TIME
/ INTERVAL
- (double) ((END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 3)) / 2), intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
403 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(4));
404 assertEquals("avg value @ level 4", (long) (END_TIME
/ INTERVAL
- (double) ((END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 4)) / 2), intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
406 } catch (TimeRangeException e
) {
407 fail(e
.getMessage());
408 } catch (StateSystemDisposedException e
) {
409 fail(e
.getMessage());
410 } catch (AttributeNotFoundException e
) {
411 fail(e
.getMessage());
412 } catch (StateValueTypeException e
) {
413 fail(e
.getMessage());
419 * Test a query range to the state system to get the maximum value in the
422 * Make sure the state system has data.
427 public void testQueryMipmapRangeMax() {
431 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
433 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, 0, START_TIME
, quark
).unboxLong();
434 assertEquals(START_TIME
/ INTERVAL
, max
);
436 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
, START_TIME
, quark
).unboxLong();
437 assertEquals(START_TIME
/ INTERVAL
, max
);
439 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
, END_TIME
/ 2, quark
).unboxLong();
440 assertEquals((END_TIME
/ 2 / INTERVAL
), max
);
442 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, 0, END_TIME
, quark
).unboxLong();
443 assertEquals(END_TIME
/ INTERVAL
, max
);
445 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, END_TIME
/ 2, END_TIME
, quark
).unboxLong();
446 assertEquals(END_TIME
/ INTERVAL
, max
);
448 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
).unboxLong();
449 assertEquals(END_TIME
/ 2 / INTERVAL
, max
);
451 } catch (AttributeNotFoundException e
) {
452 fail(e
.getMessage());
453 } catch (StateValueTypeException e
) {
454 fail(e
.getMessage());
455 } catch (TimeRangeException e
) {
456 fail(e
.getMessage());
461 * Test a query range to the state system to get the minimum value in the
464 * Make sure the state system has data.
469 public void testQueryMipmapRangeMin() {
473 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
475 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, 0, START_TIME
, quark
).unboxLong();
476 assertEquals(START_TIME
/ INTERVAL
, min
);
478 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
, START_TIME
, quark
).unboxLong();
479 assertEquals(START_TIME
/ INTERVAL
, min
);
481 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
, END_TIME
/ 2, quark
).unboxLong();
482 assertEquals((START_TIME
/ INTERVAL
), min
);
484 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, 0, END_TIME
, quark
).unboxLong();
485 assertEquals(START_TIME
/ INTERVAL
, min
);
487 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, END_TIME
/ 2, END_TIME
, quark
).unboxLong();
488 assertEquals(END_TIME
/ 2 / INTERVAL
, min
);
490 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
).unboxLong();
491 assertEquals(START_TIME
/ INTERVAL
, min
);
493 } catch (AttributeNotFoundException e
) {
494 fail(e
.getMessage());
495 } catch (StateValueTypeException e
) {
496 fail(e
.getMessage());
497 } catch (TimeRangeException e
) {
498 fail(e
.getMessage());
503 * Test a query range to the state system to get the average value in the
506 * Make sure the state system has data.
510 public void testQueryMipmapRangeAvg() {
514 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
516 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, 0, START_TIME
, quark
);
517 assertEquals((double) (START_TIME
- INTERVAL
) / INTERVAL
, avg
, DELTA
);
519 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
, START_TIME
, quark
);
520 assertEquals((double) START_TIME
/ INTERVAL
, avg
, DELTA
);
522 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
, END_TIME
/ 2, quark
);
523 assertEquals((double) (START_TIME
+ (END_TIME
/ 2 - INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
525 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, 0, END_TIME
, quark
);
526 assertEquals((double) (END_TIME
- INTERVAL
) / 2 / INTERVAL
, avg
, DELTA
);
528 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, END_TIME
/ 2, END_TIME
, quark
);
529 assertEquals((double) (END_TIME
/ 2 + (END_TIME
- INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
531 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
);
532 assertEquals((double) (START_TIME
+ (END_TIME
/ 2 - INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
534 } catch (AttributeNotFoundException e
) {
535 fail(e
.getMessage());
536 } catch (TimeRangeException e
) {
537 fail(e
.getMessage());
538 } catch (StateValueTypeException e
) {
539 fail(e
.getMessage());