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
.linuxtools
.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
.linuxtools
.internal
.tmf
.core
.statesystem
.mipmap
.AbstractTmfMipmapStateProvider
;
26 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.statesystem
.mipmap
.TmfStateSystemOperations
;
27 import org
.eclipse
.linuxtools
.statesystem
.core
.ITmfStateSystemBuilder
;
28 import org
.eclipse
.linuxtools
.statesystem
.core
.StateSystemFactory
;
29 import org
.eclipse
.linuxtools
.statesystem
.core
.backend
.IStateHistoryBackend
;
30 import org
.eclipse
.linuxtools
.statesystem
.core
.backend
.InMemoryBackend
;
31 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.AttributeNotFoundException
;
32 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.StateSystemDisposedException
;
33 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.StateValueTypeException
;
34 import org
.eclipse
.linuxtools
.statesystem
.core
.exceptions
.TimeRangeException
;
35 import org
.eclipse
.linuxtools
.statesystem
.core
.interval
.ITmfStateInterval
;
36 import org
.eclipse
.linuxtools
.statesystem
.core
.statevalue
.ITmfStateValue
.Type
;
37 import org
.eclipse
.linuxtools
.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 ssq
= StateSystemFactory
.newStateSystem(SSID
, be
);
67 mmp
.assignTargetStateSystem(ssq
);
69 for (long time
= START_TIME
; time
<= END_TIME
; time
+= INTERVAL
) {
70 long value
= time
/ INTERVAL
;
71 ITmfEvent event
= mmp
.createEvent(time
, value
);
72 mmp
.processEvent(event
);
79 * Test a single query to the state system.
81 * Make sure the state system has data.
83 * Hint: the value read should always be t / 1000
87 public void testQuery() {
90 Random rn
= new Random();
91 long time
= Math
.max(INTERVAL
, rn
.nextLong() % END_TIME
);
92 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(time
);
93 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
94 ITmfStateInterval interval
= intervals
.get(mipmapQuark
);
95 long valueLong
= interval
.getStateValue().unboxLong();
96 assertEquals(time
/ INTERVAL
, valueLong
);
98 } catch (TimeRangeException e
) {
100 } catch (StateSystemDisposedException e
) {
101 fail(e
.getMessage());
102 } catch (AttributeNotFoundException e
) {
103 fail(e
.getMessage());
104 } catch (StateValueTypeException e
) {
105 fail(e
.getMessage());
111 * Test a single query to the state system for the maxLevel.
113 * Make sure the state system has data.
117 public void testMaxLevel() {
120 Random rn
= new Random();
121 long time
= Math
.max(INTERVAL
, rn
.nextLong() % END_TIME
);
122 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(time
);
124 int maxMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
125 int nbLevelMax
= intervals
.get(maxMipmapQuark
).getStateValue().unboxInt();
126 assertEquals(NB_LEVELS
, nbLevelMax
);
128 int minMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
129 int nbLevelMin
= intervals
.get(minMipmapQuark
).getStateValue().unboxInt();
130 assertEquals(NB_LEVELS
, nbLevelMin
);
132 int avgMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
133 int nbLevelAvg
= intervals
.get(avgMipmapQuark
).getStateValue().unboxInt();
134 assertEquals(NB_LEVELS
, nbLevelAvg
);
136 } catch (TimeRangeException e
) {
137 fail(e
.getMessage());
138 } catch (StateSystemDisposedException e
) {
139 fail(e
.getMessage());
140 } catch (AttributeNotFoundException e
) {
141 fail(e
.getMessage());
142 } catch (StateValueTypeException e
) {
143 fail(e
.getMessage());
150 * Test a single query to the state system for a mip
152 * Make sure the state system has data.
156 public void testQueryEventField() {
159 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
160 int eventFieldQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
161 ITmfStateInterval interval
= intervals
.get(eventFieldQuark
);
162 long valueLong
= interval
.getStateValue().unboxLong();
163 assertEquals(TEST_TIMESTAMP
/ INTERVAL
, valueLong
);
164 } catch (TimeRangeException e
) {
165 fail(e
.getMessage());
166 } catch (StateSystemDisposedException e
) {
167 fail(e
.getMessage());
168 } catch (AttributeNotFoundException e
) {
169 fail(e
.getMessage());
170 } catch (StateValueTypeException e
) {
171 fail(e
.getMessage());
177 * Test a single query to the state system for a max
179 * Make sure the state system has data.
181 * Hint: the value read should always be greater than(t / 1000)
185 public void testQueryMipMax() {
188 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
189 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
191 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
192 for (int level
= 1; level
< NB_LEVELS
; level
++) {
193 long width
= (long) Math
.pow(RESOLUTION
, level
);
194 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
195 ITmfStateInterval interval
= intervals
.get(levelQuark
);
196 long valueLong
= interval
.getStateValue().unboxLong();
197 assertEquals("max value @ level " + level
, width
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueLong
);
198 assertEquals("max start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
199 assertEquals("max end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
202 } catch (TimeRangeException e
) {
203 fail(e
.getMessage());
204 } catch (StateSystemDisposedException e
) {
205 fail(e
.getMessage());
206 } catch (AttributeNotFoundException e
) {
207 fail(e
.getMessage());
208 } catch (StateValueTypeException e
) {
209 fail(e
.getMessage());
215 * Test a single query to the state system for a min
217 * Make sure the state system has data.
219 * Hint: the value read should always be less than(t / 1000)
222 public void testQueryMipMin() {
225 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
226 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
228 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
229 for (int level
= 1; level
< NB_LEVELS
; level
++) {
230 long width
= (long) Math
.pow(RESOLUTION
, level
);
231 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
232 ITmfStateInterval interval
= intervals
.get(levelQuark
);
233 long valueLong
= interval
.getStateValue().unboxLong();
234 assertEquals("min value @ level " + level
, 1 + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueLong
);
235 assertEquals("min start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
236 assertEquals("min end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
239 } catch (TimeRangeException e
) {
240 fail(e
.getMessage());
241 } catch (StateSystemDisposedException e
) {
242 fail(e
.getMessage());
243 } catch (AttributeNotFoundException e
) {
244 fail(e
.getMessage());
245 } catch (StateValueTypeException e
) {
246 fail(e
.getMessage());
252 * Test a single query to the state system for an average
254 * Make sure the state system has data.
256 * Hint: the value read should always be more or less(t / 1000)
260 public void testQueryMipAvg() {
263 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
264 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
266 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
267 for (int level
= 1; level
< NB_LEVELS
; level
++) {
268 long width
= (long) Math
.pow(RESOLUTION
, level
);
269 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
270 ITmfStateInterval interval
= intervals
.get(levelQuark
);
271 double valueDouble
= interval
.getStateValue().unboxDouble();
272 assertEquals("avg value @ level " + level
, 0.5 + (width
/ 2) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueDouble
, DELTA
);
273 assertEquals("avg start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
274 assertEquals("avg end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
277 } catch (TimeRangeException e
) {
278 fail(e
.getMessage());
279 } catch (StateSystemDisposedException e
) {
280 fail(e
.getMessage());
281 } catch (AttributeNotFoundException e
) {
282 fail(e
.getMessage());
283 } catch (StateValueTypeException e
) {
284 fail(e
.getMessage());
290 * Test a full query to the state system at the startTime
292 * Make sure the state system has data.
294 * Hint: the value read should always be more or less(t / 1000)
298 public void testQueryValuesOnStart() {
303 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(START_TIME
);
305 int baseQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
306 assertEquals(START_TIME
/ INTERVAL
, intervals
.get(baseQuark
).getStateValue().unboxLong());
308 int maxMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
309 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(maxMipmapQuark
).getStateValue().unboxInt());
310 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(1));
311 assertEquals("max value @ level 1", (long) Math
.pow(RESOLUTION
, 1), intervals
.get(quark
).getStateValue().unboxLong());
312 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(2));
313 assertEquals("max value @ level 2", (long) Math
.pow(RESOLUTION
, 2), intervals
.get(quark
).getStateValue().unboxLong());
314 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(3));
315 assertEquals("max value @ level 3", (long) Math
.pow(RESOLUTION
, 3), intervals
.get(quark
).getStateValue().unboxLong());
316 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(4));
317 assertEquals("max value @ level 4", (long) Math
.pow(RESOLUTION
, 4), intervals
.get(quark
).getStateValue().unboxLong());
319 int minMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
320 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(minMipmapQuark
).getStateValue().unboxInt());
321 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(1));
322 assertEquals("min value @ level 1", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
323 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(2));
324 assertEquals("min value @ level 2", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
325 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(3));
326 assertEquals("min value @ level 3", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
327 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(4));
328 assertEquals("min value @ level 4", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
330 int avgMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
331 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(avgMipmapQuark
).getStateValue().unboxInt());
332 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(1));
333 assertEquals("avg value @ level 1", 0.5 + Math
.pow(RESOLUTION
, 1) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
334 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(2));
335 assertEquals("avg value @ level 2", 0.5 + Math
.pow(RESOLUTION
, 2) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
336 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(3));
337 assertEquals("avg value @ level 3", 0.5 + Math
.pow(RESOLUTION
, 3) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
338 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(4));
339 assertEquals("avg value @ level 4", 0.5 + Math
.pow(RESOLUTION
, 4) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
341 } catch (TimeRangeException e
) {
342 fail(e
.getMessage());
343 } catch (StateSystemDisposedException e
) {
344 fail(e
.getMessage());
345 } catch (AttributeNotFoundException e
) {
346 fail(e
.getMessage());
347 } catch (StateValueTypeException e
) {
348 fail(e
.getMessage());
354 * Test a full query to the state system when the end time
356 * Make sure the state system has data.
358 * Hint: the value read should always be more or less(t / 1000)
362 public void testQueryValuesOnClose() {
367 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(END_TIME
);
369 int baseQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
370 assertEquals(END_TIME
/ INTERVAL
, intervals
.get(baseQuark
).getStateValue().unboxLong());
372 int maxMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
373 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(maxMipmapQuark
).getStateValue().unboxInt());
374 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(1));
375 assertEquals("max value @ level 1", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
376 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(2));
377 assertEquals("max value @ level 2", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
378 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(3));
379 assertEquals("max value @ level 3", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
380 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(4));
381 assertEquals("max value @ level 4", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
383 int minMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
384 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(minMipmapQuark
).getStateValue().unboxInt());
385 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(1));
386 assertEquals("min value @ level 1", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 1), intervals
.get(quark
).getStateValue().unboxLong());
387 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(2));
388 assertEquals("min value @ level 2", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 2), intervals
.get(quark
).getStateValue().unboxLong());
389 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(3));
390 assertEquals("min value @ level 3", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 3), intervals
.get(quark
).getStateValue().unboxLong());
391 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(4));
392 assertEquals("min value @ level 4", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 4), intervals
.get(quark
).getStateValue().unboxLong());
394 int avgMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
395 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(avgMipmapQuark
).getStateValue().unboxInt());
396 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(1));
397 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
);
398 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(2));
399 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
);
400 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(3));
401 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
);
402 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(4));
403 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
);
405 } catch (TimeRangeException e
) {
406 fail(e
.getMessage());
407 } catch (StateSystemDisposedException e
) {
408 fail(e
.getMessage());
409 } catch (AttributeNotFoundException e
) {
410 fail(e
.getMessage());
411 } catch (StateValueTypeException e
) {
412 fail(e
.getMessage());
418 * Test a query range to the state system to get the maximum value in the
421 * Make sure the state system has data.
426 public void testQueryMipmapRangeMax() {
430 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
432 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, 0, START_TIME
, quark
).unboxLong();
433 assertEquals(START_TIME
/ INTERVAL
, max
);
435 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
, START_TIME
, quark
).unboxLong();
436 assertEquals(START_TIME
/ INTERVAL
, max
);
438 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
, END_TIME
/ 2, quark
).unboxLong();
439 assertEquals((END_TIME
/ 2 / INTERVAL
), max
);
441 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, 0, END_TIME
, quark
).unboxLong();
442 assertEquals(END_TIME
/ INTERVAL
, max
);
444 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, END_TIME
/ 2, END_TIME
, quark
).unboxLong();
445 assertEquals(END_TIME
/ INTERVAL
, max
);
447 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
).unboxLong();
448 assertEquals(END_TIME
/ 2 / INTERVAL
, max
);
450 } catch (AttributeNotFoundException e
) {
451 fail(e
.getMessage());
452 } catch (StateValueTypeException e
) {
453 fail(e
.getMessage());
454 } catch (TimeRangeException e
) {
455 fail(e
.getMessage());
460 * Test a query range to the state system to get the minimum value in the
463 * Make sure the state system has data.
468 public void testQueryMipmapRangeMin() {
472 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
474 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, 0, START_TIME
, quark
).unboxLong();
475 assertEquals(START_TIME
/ INTERVAL
, min
);
477 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
, START_TIME
, quark
).unboxLong();
478 assertEquals(START_TIME
/ INTERVAL
, min
);
480 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
, END_TIME
/ 2, quark
).unboxLong();
481 assertEquals((START_TIME
/ INTERVAL
), min
);
483 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, 0, END_TIME
, quark
).unboxLong();
484 assertEquals(START_TIME
/ INTERVAL
, min
);
486 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, END_TIME
/ 2, END_TIME
, quark
).unboxLong();
487 assertEquals(END_TIME
/ 2 / INTERVAL
, min
);
489 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
).unboxLong();
490 assertEquals(START_TIME
/ INTERVAL
, min
);
492 } catch (AttributeNotFoundException e
) {
493 fail(e
.getMessage());
494 } catch (StateValueTypeException e
) {
495 fail(e
.getMessage());
496 } catch (TimeRangeException e
) {
497 fail(e
.getMessage());
502 * Test a query range to the state system to get the average value in the
505 * Make sure the state system has data.
509 public void testQueryMipmapRangeAvg() {
513 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
515 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, 0, START_TIME
, quark
);
516 assertEquals((double) (START_TIME
- INTERVAL
) / INTERVAL
, avg
, DELTA
);
518 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
, START_TIME
, quark
);
519 assertEquals((double) START_TIME
/ INTERVAL
, avg
, DELTA
);
521 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
, END_TIME
/ 2, quark
);
522 assertEquals((double) (START_TIME
+ (END_TIME
/ 2 - INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
524 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, 0, END_TIME
, quark
);
525 assertEquals((double) (END_TIME
- INTERVAL
) / 2 / INTERVAL
, avg
, DELTA
);
527 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, END_TIME
/ 2, END_TIME
, quark
);
528 assertEquals((double) (END_TIME
/ 2 + (END_TIME
- INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
530 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
);
531 assertEquals((double) (START_TIME
+ (END_TIME
/ 2 - INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
533 } catch (AttributeNotFoundException e
) {
534 fail(e
.getMessage());
535 } catch (TimeRangeException e
) {
536 fail(e
.getMessage());
537 } catch (StateValueTypeException e
) {
538 fail(e
.getMessage());