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
.StateSystem
;
26 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.statesystem
.backends
.IStateHistoryBackend
;
27 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.statesystem
.backends
.InMemoryBackend
;
28 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.statesystem
.mipmap
.AbstractTmfMipmapStateProvider
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.AttributeNotFoundException
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.StateSystemDisposedException
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.StateValueTypeException
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TimeRangeException
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.interval
.ITmfStateInterval
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.statesystem
.TmfStateSystemOperations
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.statevalue
.ITmfStateValue
.Type
;
37 import org
.junit
.BeforeClass
;
38 import org
.junit
.Test
;
41 * @author Jean-Christian Kouamé
44 public class TmfMipmapStateProviderTest
{
46 @NonNull private static final String SSID
= "mimap-test";
47 private static final String TEST_ATTRIBUTE_NAME
= TmfMipmapStateProviderStub
.TEST_ATTRIBUTE_NAME
;
48 private static final int NB_LEVELS
= 4;
49 private static final long START_TIME
= 1000L;
50 private static final long END_TIME
= 100000000L;
51 private static final long INTERVAL
= 1000L;
52 private static final int RESOLUTION
= 16;
53 private static final double DELTA
= 0.0001;
54 private static final long TEST_TIMESTAMP
= 12345000L;
55 private static StateSystem ssq
;
58 * Startup code, build a state system with n attributes always going up
62 public static void init() {
63 TmfMipmapStateProviderStub mmp
= new TmfMipmapStateProviderStub(RESOLUTION
, Type
.LONG
);
64 IStateHistoryBackend be
= new InMemoryBackend(0);
65 ssq
= new StateSystem(SSID
, be
);
66 mmp
.assignTargetStateSystem(ssq
);
68 for (long time
= START_TIME
; time
<= END_TIME
; time
+= INTERVAL
) {
69 long value
= time
/ INTERVAL
;
70 ITmfEvent event
= mmp
.createEvent(time
, value
);
71 mmp
.processEvent(event
);
78 * Test a single query to the state system.
80 * Make sure the state system has data.
82 * Hint: the value read should always be t / 1000
86 public void testQuery() {
89 Random rn
= new Random();
90 long time
= Math
.max(INTERVAL
, rn
.nextLong() % END_TIME
);
91 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(time
);
92 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
93 ITmfStateInterval interval
= intervals
.get(mipmapQuark
);
94 long valueLong
= interval
.getStateValue().unboxLong();
95 assertEquals(time
/ INTERVAL
, valueLong
);
97 } catch (TimeRangeException e
) {
99 } catch (StateSystemDisposedException e
) {
100 fail(e
.getMessage());
101 } catch (AttributeNotFoundException e
) {
102 fail(e
.getMessage());
103 } catch (StateValueTypeException e
) {
104 fail(e
.getMessage());
110 * Test a single query to the state system for the maxLevel.
112 * Make sure the state system has data.
116 public void testMaxLevel() {
119 Random rn
= new Random();
120 long time
= Math
.max(INTERVAL
, rn
.nextLong() % END_TIME
);
121 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(time
);
123 int maxMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
124 int nbLevelMax
= intervals
.get(maxMipmapQuark
).getStateValue().unboxInt();
125 assertEquals(NB_LEVELS
, nbLevelMax
);
127 int minMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
128 int nbLevelMin
= intervals
.get(minMipmapQuark
).getStateValue().unboxInt();
129 assertEquals(NB_LEVELS
, nbLevelMin
);
131 int avgMipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
132 int nbLevelAvg
= intervals
.get(avgMipmapQuark
).getStateValue().unboxInt();
133 assertEquals(NB_LEVELS
, nbLevelAvg
);
135 } catch (TimeRangeException e
) {
136 fail(e
.getMessage());
137 } catch (StateSystemDisposedException e
) {
138 fail(e
.getMessage());
139 } catch (AttributeNotFoundException e
) {
140 fail(e
.getMessage());
141 } catch (StateValueTypeException e
) {
142 fail(e
.getMessage());
149 * Test a single query to the state system for a mip
151 * Make sure the state system has data.
155 public void testQueryEventField() {
158 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
159 int eventFieldQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
160 ITmfStateInterval interval
= intervals
.get(eventFieldQuark
);
161 long valueLong
= interval
.getStateValue().unboxLong();
162 assertEquals(TEST_TIMESTAMP
/ INTERVAL
, valueLong
);
163 } catch (TimeRangeException e
) {
164 fail(e
.getMessage());
165 } catch (StateSystemDisposedException e
) {
166 fail(e
.getMessage());
167 } catch (AttributeNotFoundException e
) {
168 fail(e
.getMessage());
169 } catch (StateValueTypeException e
) {
170 fail(e
.getMessage());
176 * Test a single query to the state system for a max
178 * Make sure the state system has data.
180 * Hint: the value read should always be greater than(t / 1000)
184 public void testQueryMipMax() {
187 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
188 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
190 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
191 for (int level
= 1; level
< NB_LEVELS
; level
++) {
192 long width
= (long) Math
.pow(RESOLUTION
, level
);
193 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
194 ITmfStateInterval interval
= intervals
.get(levelQuark
);
195 long valueLong
= interval
.getStateValue().unboxLong();
196 assertEquals("max value @ level " + level
, width
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueLong
);
197 assertEquals("max start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
198 assertEquals("max end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
201 } catch (TimeRangeException e
) {
202 fail(e
.getMessage());
203 } catch (StateSystemDisposedException e
) {
204 fail(e
.getMessage());
205 } catch (AttributeNotFoundException e
) {
206 fail(e
.getMessage());
207 } catch (StateValueTypeException e
) {
208 fail(e
.getMessage());
214 * Test a single query to the state system for a min
216 * Make sure the state system has data.
218 * Hint: the value read should always be less than(t / 1000)
221 public void testQueryMipMin() {
224 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
225 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
227 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
228 for (int level
= 1; level
< NB_LEVELS
; level
++) {
229 long width
= (long) Math
.pow(RESOLUTION
, level
);
230 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
231 ITmfStateInterval interval
= intervals
.get(levelQuark
);
232 long valueLong
= interval
.getStateValue().unboxLong();
233 assertEquals("min value @ level " + level
, 1 + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueLong
);
234 assertEquals("min start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
235 assertEquals("min end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
238 } catch (TimeRangeException e
) {
239 fail(e
.getMessage());
240 } catch (StateSystemDisposedException e
) {
241 fail(e
.getMessage());
242 } catch (AttributeNotFoundException e
) {
243 fail(e
.getMessage());
244 } catch (StateValueTypeException e
) {
245 fail(e
.getMessage());
251 * Test a single query to the state system for an average
253 * Make sure the state system has data.
255 * Hint: the value read should always be more or less(t / 1000)
259 public void testQueryMipAvg() {
262 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(TEST_TIMESTAMP
);
263 int mipmapQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
265 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(mipmapQuark
).getStateValue().unboxInt());
266 for (int level
= 1; level
< NB_LEVELS
; level
++) {
267 long width
= (long) Math
.pow(RESOLUTION
, level
);
268 int levelQuark
= ssq
.getQuarkRelative(mipmapQuark
, String
.valueOf(level
));
269 ITmfStateInterval interval
= intervals
.get(levelQuark
);
270 double valueDouble
= interval
.getStateValue().unboxDouble();
271 assertEquals("avg value @ level " + level
, 0.5 + (width
/ 2) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
, valueDouble
, DELTA
);
272 assertEquals("avg start time @ level " + level
, START_TIME
+ (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getStartTime());
273 assertEquals("avg end time @ level " + level
, START_TIME
+ (INTERVAL
* width
) + (((TEST_TIMESTAMP
- START_TIME
) / INTERVAL
) / width
) * width
* INTERVAL
, interval
.getEndTime() + 1);
276 } catch (TimeRangeException e
) {
277 fail(e
.getMessage());
278 } catch (StateSystemDisposedException e
) {
279 fail(e
.getMessage());
280 } catch (AttributeNotFoundException e
) {
281 fail(e
.getMessage());
282 } catch (StateValueTypeException e
) {
283 fail(e
.getMessage());
289 * Test a full query to the state system at the startTime
291 * Make sure the state system has data.
293 * Hint: the value read should always be more or less(t / 1000)
297 public void testQueryValuesOnStart() {
302 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(START_TIME
);
304 int baseQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
305 assertEquals(START_TIME
/ INTERVAL
, intervals
.get(baseQuark
).getStateValue().unboxLong());
307 int maxMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
308 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(maxMipmapQuark
).getStateValue().unboxInt());
309 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(1));
310 assertEquals("max value @ level 1", (long) Math
.pow(RESOLUTION
, 1), intervals
.get(quark
).getStateValue().unboxLong());
311 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(2));
312 assertEquals("max value @ level 2", (long) Math
.pow(RESOLUTION
, 2), intervals
.get(quark
).getStateValue().unboxLong());
313 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(3));
314 assertEquals("max value @ level 3", (long) Math
.pow(RESOLUTION
, 3), intervals
.get(quark
).getStateValue().unboxLong());
315 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(4));
316 assertEquals("max value @ level 4", (long) Math
.pow(RESOLUTION
, 4), intervals
.get(quark
).getStateValue().unboxLong());
318 int minMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
319 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(minMipmapQuark
).getStateValue().unboxInt());
320 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(1));
321 assertEquals("min value @ level 1", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
322 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(2));
323 assertEquals("min value @ level 2", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
324 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(3));
325 assertEquals("min value @ level 3", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
326 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(4));
327 assertEquals("min value @ level 4", START_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
329 int avgMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
330 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(avgMipmapQuark
).getStateValue().unboxInt());
331 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(1));
332 assertEquals("avg value @ level 1", 0.5 + Math
.pow(RESOLUTION
, 1) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
333 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(2));
334 assertEquals("avg value @ level 2", 0.5 + Math
.pow(RESOLUTION
, 2) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
335 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(3));
336 assertEquals("avg value @ level 3", 0.5 + Math
.pow(RESOLUTION
, 3) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
337 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(4));
338 assertEquals("avg value @ level 4", 0.5 + Math
.pow(RESOLUTION
, 4) / 2, intervals
.get(quark
).getStateValue().unboxDouble(), DELTA
);
340 } catch (TimeRangeException e
) {
341 fail(e
.getMessage());
342 } catch (StateSystemDisposedException e
) {
343 fail(e
.getMessage());
344 } catch (AttributeNotFoundException e
) {
345 fail(e
.getMessage());
346 } catch (StateValueTypeException e
) {
347 fail(e
.getMessage());
353 * Test a full query to the state system when the end time
355 * Make sure the state system has data.
357 * Hint: the value read should always be more or less(t / 1000)
361 public void testQueryValuesOnClose() {
366 List
<ITmfStateInterval
> intervals
= ssq
.queryFullState(END_TIME
);
368 int baseQuark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
369 assertEquals(END_TIME
/ INTERVAL
, intervals
.get(baseQuark
).getStateValue().unboxLong());
371 int maxMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MAX_STRING
);
372 assertEquals("max nblevels", NB_LEVELS
, intervals
.get(maxMipmapQuark
).getStateValue().unboxInt());
373 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(1));
374 assertEquals("max value @ level 1", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
375 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(2));
376 assertEquals("max value @ level 2", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
377 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(3));
378 assertEquals("max value @ level 3", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
379 quark
= ssq
.getQuarkRelative(maxMipmapQuark
, String
.valueOf(4));
380 assertEquals("max value @ level 4", END_TIME
/ INTERVAL
, intervals
.get(quark
).getStateValue().unboxLong());
382 int minMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.MIN_STRING
);
383 assertEquals("min nblevels", NB_LEVELS
, intervals
.get(minMipmapQuark
).getStateValue().unboxInt());
384 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(1));
385 assertEquals("min value @ level 1", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 1), intervals
.get(quark
).getStateValue().unboxLong());
386 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(2));
387 assertEquals("min value @ level 2", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 2), intervals
.get(quark
).getStateValue().unboxLong());
388 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(3));
389 assertEquals("min value @ level 3", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 3), intervals
.get(quark
).getStateValue().unboxLong());
390 quark
= ssq
.getQuarkRelative(minMipmapQuark
, String
.valueOf(4));
391 assertEquals("min value @ level 4", END_TIME
/ INTERVAL
- (END_TIME
- START_TIME
) / INTERVAL
% (long) Math
.pow(RESOLUTION
, 4), intervals
.get(quark
).getStateValue().unboxLong());
393 int avgMipmapQuark
= ssq
.getQuarkRelative(baseQuark
, AbstractTmfMipmapStateProvider
.AVG_STRING
);
394 assertEquals("avg nblevels", NB_LEVELS
, intervals
.get(avgMipmapQuark
).getStateValue().unboxInt());
395 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(1));
396 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
);
397 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(2));
398 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
);
399 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(3));
400 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
);
401 quark
= ssq
.getQuarkRelative(avgMipmapQuark
, String
.valueOf(4));
402 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
);
404 } catch (TimeRangeException e
) {
405 fail(e
.getMessage());
406 } catch (StateSystemDisposedException e
) {
407 fail(e
.getMessage());
408 } catch (AttributeNotFoundException e
) {
409 fail(e
.getMessage());
410 } catch (StateValueTypeException e
) {
411 fail(e
.getMessage());
417 * Test a query range to the state system to get the maximum value in the
420 * Make sure the state system has data.
425 public void testQueryMipmapRangeMax() {
429 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
431 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, 0, START_TIME
, quark
).unboxLong();
432 assertEquals(START_TIME
/ INTERVAL
, max
);
434 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
, START_TIME
, quark
).unboxLong();
435 assertEquals(START_TIME
/ INTERVAL
, max
);
437 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
, END_TIME
/ 2, quark
).unboxLong();
438 assertEquals((END_TIME
/ 2 / INTERVAL
), max
);
440 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, 0, END_TIME
, quark
).unboxLong();
441 assertEquals(END_TIME
/ INTERVAL
, max
);
443 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, END_TIME
/ 2, END_TIME
, quark
).unboxLong();
444 assertEquals(END_TIME
/ INTERVAL
, max
);
446 max
= TmfStateSystemOperations
.queryRangeMax(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
).unboxLong();
447 assertEquals(END_TIME
/ 2 / INTERVAL
, max
);
449 } catch (AttributeNotFoundException e
) {
450 fail(e
.getMessage());
451 } catch (StateValueTypeException e
) {
452 fail(e
.getMessage());
453 } catch (TimeRangeException e
) {
454 fail(e
.getMessage());
459 * Test a query range to the state system to get the minimum value in the
462 * Make sure the state system has data.
467 public void testQueryMipmapRangeMin() {
471 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
473 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, 0, START_TIME
, quark
).unboxLong();
474 assertEquals(START_TIME
/ INTERVAL
, min
);
476 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
, START_TIME
, quark
).unboxLong();
477 assertEquals(START_TIME
/ INTERVAL
, min
);
479 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
, END_TIME
/ 2, quark
).unboxLong();
480 assertEquals((START_TIME
/ INTERVAL
), min
);
482 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, 0, END_TIME
, quark
).unboxLong();
483 assertEquals(START_TIME
/ INTERVAL
, min
);
485 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, END_TIME
/ 2, END_TIME
, quark
).unboxLong();
486 assertEquals(END_TIME
/ 2 / INTERVAL
, min
);
488 min
= TmfStateSystemOperations
.queryRangeMin(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
).unboxLong();
489 assertEquals(START_TIME
/ INTERVAL
, min
);
491 } catch (AttributeNotFoundException e
) {
492 fail(e
.getMessage());
493 } catch (StateValueTypeException e
) {
494 fail(e
.getMessage());
495 } catch (TimeRangeException e
) {
496 fail(e
.getMessage());
501 * Test a query range to the state system to get the average value in the
504 * Make sure the state system has data.
508 public void testQueryMipmapRangeAvg() {
512 int quark
= ssq
.getQuarkAbsolute(TEST_ATTRIBUTE_NAME
);
514 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, 0, START_TIME
, quark
);
515 assertEquals((double) (START_TIME
- INTERVAL
) / INTERVAL
, avg
, DELTA
);
517 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
, START_TIME
, quark
);
518 assertEquals((double) START_TIME
/ INTERVAL
, avg
, DELTA
);
520 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
, END_TIME
/ 2, quark
);
521 assertEquals((double) (START_TIME
+ (END_TIME
/ 2 - INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
523 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, 0, END_TIME
, quark
);
524 assertEquals((double) (END_TIME
- INTERVAL
) / 2 / INTERVAL
, avg
, DELTA
);
526 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, END_TIME
/ 2, END_TIME
, quark
);
527 assertEquals((double) (END_TIME
/ 2 + (END_TIME
- INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
529 avg
= TmfStateSystemOperations
.queryRangeAverage(ssq
, START_TIME
- INTERVAL
/ 2, END_TIME
/ 2 + INTERVAL
/ 2, quark
);
530 assertEquals((double) (START_TIME
+ (END_TIME
/ 2 - INTERVAL
)) / 2 / INTERVAL
, avg
, DELTA
);
532 } catch (AttributeNotFoundException e
) {
533 fail(e
.getMessage());
534 } catch (TimeRangeException e
) {
535 fail(e
.getMessage());
536 } catch (StateValueTypeException e
) {
537 fail(e
.getMessage());