org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013 Ericsson
   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  *     Jean-Christian Kouamé - Initial API and implementation
  11  *     Patrick Tasse - Updates to mipmap feature
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.tests.statesystem.mipmap;
  15
  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;
  20
  21 import java.util.List;
  22 import java.util.Random;
  23
  24 import org.eclipse.linuxtools.internal.tmf.core.statesystem.StateSystem;
  25 import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend;
  26 import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.InMemoryBackend;
  27 import org.eclipse.linuxtools.internal.tmf.core.statesystem.mipmap.AbstractTmfMipmapStateProvider;
  28 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  29 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  30 import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
  31 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  32 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  33 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  34 import org.eclipse.linuxtools.tmf.core.statesystem.TmfStateSystemOperations;
  35 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue.Type;
  36 import org.junit.BeforeClass;
  37 import org.junit.Test;
  38
  39 /**
  40  * @author Jean-Christian Kouamé
  41  *
  42  */
  43 public class TmfMipmapStateProviderTest {
  44     private static final String TEST_ATTRIBUTE_NAME = TmfMipmapStateProviderStub.TEST_ATTRIBUTE_NAME;
  45     private static final int NB_LEVELS = 4;
  46     private static final long START_TIME = 1000L;
  47     private static final long END_TIME = 100000000L;
  48     private static final long INTERVAL = 1000L;
  49     private static final int RESOLUTION = 16;
  50     private static final double DELTA = 0.0001;
  51     private static final long TEST_TIMESTAMP = 12345000L;
  52     private static StateSystem ssq;
  53
  54     /**
  55      * Startup code, build a state system with n attributes always going up
  56      * linearly
  57      */
  58     @BeforeClass
  59     public static void init() {
  60         TmfMipmapStateProviderStub mmp = new TmfMipmapStateProviderStub(RESOLUTION, Type.LONG);
  61         IStateHistoryBackend be = new InMemoryBackend(0);
  62         ssq = new StateSystem(be);
  63         mmp.assignTargetStateSystem(ssq);
  64
  65         for (long time = START_TIME; time <= END_TIME; time += INTERVAL) {
  66             long value = time / INTERVAL;
  67             ITmfEvent event = mmp.createEvent(time, value);
  68             mmp.processEvent(event);
  69         }
  70         mmp.dispose();
  71         ssq.waitUntilBuilt();
  72     }
  73
  74     /**
  75      * Test a single query to the state system.
  76      *
  77      * Make sure the state system has data.
  78      *
  79      * Hint: the value read should always be t / 1000
  80      *
  81      */
  82     @Test
  83     public void testQuery() {
  84         assertNotNull(ssq);
  85         try {
  86             Random rn = new Random();
  87             long time = Math.max(INTERVAL, rn.nextLong() % END_TIME);
  88             List<ITmfStateInterval> intervals = ssq.queryFullState(time);
  89             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
  90             ITmfStateInterval interval = intervals.get(mipmapQuark);
  91             long valueLong = interval.getStateValue().unboxLong();
  92             assertEquals(time / INTERVAL, valueLong);
  93
  94         } catch (TimeRangeException e) {
  95             fail(e.getMessage());
  96         } catch (StateSystemDisposedException e) {
  97             fail(e.getMessage());
  98         } catch (AttributeNotFoundException e) {
  99             fail(e.getMessage());
 100         } catch (StateValueTypeException e) {
 101             fail(e.getMessage());
 102         }
 103         assertTrue(true);
 104     }
 105
 106     /**
 107      * Test a single query to the state system for the maxLevel.
 108      *
 109      * Make sure the state system has data.
 110      *
 111      */
 112     @Test
 113     public void testMaxLevel() {
 114         assertNotNull(ssq);
 115         try {
 116             Random rn = new Random();
 117             long time = Math.max(INTERVAL, rn.nextLong() % END_TIME);
 118             List<ITmfStateInterval> intervals = ssq.queryFullState(time);
 119
 120             int maxMipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MAX_STRING);
 121             int nbLevelMax = intervals.get(maxMipmapQuark).getStateValue().unboxInt();
 122             assertEquals(NB_LEVELS, nbLevelMax);
 123
 124             int minMipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MIN_STRING);
 125             int nbLevelMin = intervals.get(minMipmapQuark).getStateValue().unboxInt();
 126             assertEquals(NB_LEVELS, nbLevelMin);
 127
 128             int avgMipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.AVG_STRING);
 129             int nbLevelAvg = intervals.get(avgMipmapQuark).getStateValue().unboxInt();
 130             assertEquals(NB_LEVELS, nbLevelAvg);
 131
 132         } catch (TimeRangeException e) {
 133             fail(e.getMessage());
 134         } catch (StateSystemDisposedException e) {
 135             fail(e.getMessage());
 136         } catch (AttributeNotFoundException e) {
 137             fail(e.getMessage());
 138         } catch (StateValueTypeException e) {
 139             fail(e.getMessage());
 140         }
 141         assertTrue(true);
 142
 143     }
 144
 145     /**
 146      * Test a single query to the state system for a mip
 147      *
 148      * Make sure the state system has data.
 149      *
 150      */
 151     @Test
 152     public void testQueryEventField() {
 153         assertNotNull(ssq);
 154         try {
 155             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 156             int eventFieldQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 157             ITmfStateInterval interval = intervals.get(eventFieldQuark);
 158             long valueLong = interval.getStateValue().unboxLong();
 159             assertEquals(TEST_TIMESTAMP / INTERVAL, valueLong);
 160         } catch (TimeRangeException e) {
 161             fail(e.getMessage());
 162         } catch (StateSystemDisposedException e) {
 163             fail(e.getMessage());
 164         } catch (AttributeNotFoundException e) {
 165             fail(e.getMessage());
 166         } catch (StateValueTypeException e) {
 167             fail(e.getMessage());
 168         }
 169         assertTrue(true);
 170     }
 171
 172     /**
 173      * Test a single query to the state system for a max
 174      *
 175      * Make sure the state system has data.
 176      *
 177      * Hint: the value read should always be greater than(t / 1000)
 178      *
 179      */
 180     @Test
 181     public void testQueryMipMax() {
 182         assertNotNull(ssq);
 183         try {
 184             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 185             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MAX_STRING);
 186
 187             assertEquals("max nblevels", NB_LEVELS, intervals.get(mipmapQuark).getStateValue().unboxInt());
 188             for (int level = 1; level < NB_LEVELS; level++) {
 189                 long width = (long) Math.pow(RESOLUTION, level);
 190                 int levelQuark = ssq.getQuarkRelative(mipmapQuark, String.valueOf(level));
 191                 ITmfStateInterval interval = intervals.get(levelQuark);
 192                 long valueLong = interval.getStateValue().unboxLong();
 193                 assertEquals("max value @ level " + level, width + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width, valueLong);
 194                 assertEquals("max start time @ level " + level, START_TIME + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width * INTERVAL, interval.getStartTime());
 195                 assertEquals("max end time @ level " + level, START_TIME + (INTERVAL * width) + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width * INTERVAL, interval.getEndTime() + 1);
 196             }
 197
 198         } catch (TimeRangeException e) {
 199             fail(e.getMessage());
 200         } catch (StateSystemDisposedException e) {
 201             fail(e.getMessage());
 202         } catch (AttributeNotFoundException e) {
 203             fail(e.getMessage());
 204         } catch (StateValueTypeException e) {
 205             fail(e.getMessage());
 206         }
 207         assertTrue(true);
 208     }
 209
 210     /**
 211      * Test a single query to the state system for a min
 212      *
 213      * Make sure the state system has data.
 214      *
 215      * Hint: the value read should always be less than(t / 1000)
 216      */
 217     @Test
 218     public void testQueryMipMin() {
 219         assertNotNull(ssq);
 220         try {
 221             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 222             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MIN_STRING);
 223
 224             assertEquals("min nblevels", NB_LEVELS, intervals.get(mipmapQuark).getStateValue().unboxInt());
 225             for (int level = 1; level < NB_LEVELS; level++) {
 226                 long width = (long) Math.pow(RESOLUTION, level);
 227                 int levelQuark = ssq.getQuarkRelative(mipmapQuark, String.valueOf(level));
 228                 ITmfStateInterval interval = intervals.get(levelQuark);
 229                 long valueLong = interval.getStateValue().unboxLong();
 230                 assertEquals("min value @ level " + level, 1 + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width, valueLong);
 231                 assertEquals("min start time @ level " + level, START_TIME + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width * INTERVAL, interval.getStartTime());
 232                 assertEquals("min end time @ level " + level, START_TIME + (INTERVAL * width) + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width * INTERVAL, interval.getEndTime() + 1);
 233             }
 234
 235         } catch (TimeRangeException e) {
 236             fail(e.getMessage());
 237         } catch (StateSystemDisposedException e) {
 238             fail(e.getMessage());
 239         } catch (AttributeNotFoundException e) {
 240             fail(e.getMessage());
 241         } catch (StateValueTypeException e) {
 242             fail(e.getMessage());
 243         }
 244         assertTrue(true);
 245     }
 246
 247     /**
 248      * Test a single query to the state system for an average
 249      *
 250      * Make sure the state system has data.
 251      *
 252      * Hint: the value read should always be more or less(t / 1000)
 253      *
 254      */
 255     @Test
 256     public void testQueryMipAvg() {
 257         assertNotNull(ssq);
 258         try {
 259             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 260             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.AVG_STRING);
 261
 262             assertEquals("avg nblevels", NB_LEVELS, intervals.get(mipmapQuark).getStateValue().unboxInt());
 263             for (int level = 1; level < NB_LEVELS; level++) {
 264                 long width = (long) Math.pow(RESOLUTION, level);
 265                 int levelQuark = ssq.getQuarkRelative(mipmapQuark, String.valueOf(level));
 266                 ITmfStateInterval interval = intervals.get(levelQuark);
 267                 double valueDouble = interval.getStateValue().unboxDouble();
 268                 assertEquals("avg value @ level " + level, 0.5 + (width / 2) + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width, valueDouble, DELTA);
 269                 assertEquals("avg start time @ level " + level, START_TIME + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width * INTERVAL, interval.getStartTime());
 270                 assertEquals("avg end time @ level " + level, START_TIME + (INTERVAL * width) + (((TEST_TIMESTAMP - START_TIME) / INTERVAL) / width) * width * INTERVAL, interval.getEndTime() + 1);
 271             }
 272
 273         } catch (TimeRangeException e) {
 274             fail(e.getMessage());
 275         } catch (StateSystemDisposedException e) {
 276             fail(e.getMessage());
 277         } catch (AttributeNotFoundException e) {
 278             fail(e.getMessage());
 279         } catch (StateValueTypeException e) {
 280             fail(e.getMessage());
 281         }
 282         assertTrue(true);
 283     }
 284
 285     /**
 286      * Test a full query to the state system at the startTime
 287      *
 288      * Make sure the state system has data.
 289      *
 290      * Hint: the value read should always be more or less(t / 1000)
 291      *
 292      */
 293     @Test
 294     public void testQueryValuesOnStart() {
 295         assertNotNull(ssq);
 296         try {
 297             int quark;
 298
 299             List<ITmfStateInterval> intervals = ssq.queryFullState(START_TIME);
 300
 301             int baseQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 302             assertEquals(START_TIME / INTERVAL, intervals.get(baseQuark).getStateValue().unboxLong());
 303
 304             int maxMipmapQuark = ssq.getQuarkRelative(baseQuark, AbstractTmfMipmapStateProvider.MAX_STRING);
 305             assertEquals("max nblevels", NB_LEVELS, intervals.get(maxMipmapQuark).getStateValue().unboxInt());
 306             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(1));
 307             assertEquals("max value @ level 1", (long) Math.pow(RESOLUTION, 1), intervals.get(quark).getStateValue().unboxLong());
 308             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(2));
 309             assertEquals("max value @ level 2", (long) Math.pow(RESOLUTION, 2), intervals.get(quark).getStateValue().unboxLong());
 310             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(3));
 311             assertEquals("max value @ level 3", (long) Math.pow(RESOLUTION, 3), intervals.get(quark).getStateValue().unboxLong());
 312             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(4));
 313             assertEquals("max value @ level 4", (long) Math.pow(RESOLUTION, 4), intervals.get(quark).getStateValue().unboxLong());
 314
 315             int minMipmapQuark = ssq.getQuarkRelative(baseQuark, AbstractTmfMipmapStateProvider.MIN_STRING);
 316             assertEquals("min nblevels", NB_LEVELS, intervals.get(minMipmapQuark).getStateValue().unboxInt());
 317             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(1));
 318             assertEquals("min value @ level 1", START_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 319             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(2));
 320             assertEquals("min value @ level 2", START_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 321             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(3));
 322             assertEquals("min value @ level 3", START_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 323             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(4));
 324             assertEquals("min value @ level 4", START_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 325
 326             int avgMipmapQuark = ssq.getQuarkRelative(baseQuark, AbstractTmfMipmapStateProvider.AVG_STRING);
 327             assertEquals("avg nblevels", NB_LEVELS, intervals.get(avgMipmapQuark).getStateValue().unboxInt());
 328             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(1));
 329             assertEquals("avg value @ level 1", 0.5 + Math.pow(RESOLUTION, 1) / 2, intervals.get(quark).getStateValue().unboxDouble(), DELTA);
 330             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(2));
 331             assertEquals("avg value @ level 2", 0.5 + Math.pow(RESOLUTION, 2) / 2, intervals.get(quark).getStateValue().unboxDouble(), DELTA);
 332             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(3));
 333             assertEquals("avg value @ level 3", 0.5 + Math.pow(RESOLUTION, 3) / 2, intervals.get(quark).getStateValue().unboxDouble(), DELTA);
 334             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(4));
 335             assertEquals("avg value @ level 4", 0.5 + Math.pow(RESOLUTION, 4) / 2, intervals.get(quark).getStateValue().unboxDouble(), DELTA);
 336
 337         } catch (TimeRangeException e) {
 338             fail(e.getMessage());
 339         } catch (StateSystemDisposedException e) {
 340             fail(e.getMessage());
 341         } catch (AttributeNotFoundException e) {
 342             fail(e.getMessage());
 343         } catch (StateValueTypeException e) {
 344             fail(e.getMessage());
 345         }
 346         assertTrue(true);
 347     }
 348
 349     /**
 350      * Test a full query to the state system when the end time
 351      *
 352      * Make sure the state system has data.
 353      *
 354      * Hint: the value read should always be more or less(t / 1000)
 355      *
 356      */
 357     @Test
 358     public void testQueryValuesOnClose() {
 359         assertNotNull(ssq);
 360         try {
 361             int quark;
 362
 363             List<ITmfStateInterval> intervals = ssq.queryFullState(END_TIME);
 364
 365             int baseQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 366             assertEquals(END_TIME / INTERVAL, intervals.get(baseQuark).getStateValue().unboxLong());
 367
 368             int maxMipmapQuark = ssq.getQuarkRelative(baseQuark, AbstractTmfMipmapStateProvider.MAX_STRING);
 369             assertEquals("max nblevels", NB_LEVELS, intervals.get(maxMipmapQuark).getStateValue().unboxInt());
 370             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(1));
 371             assertEquals("max value @ level 1", END_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 372             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(2));
 373             assertEquals("max value @ level 2", END_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 374             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(3));
 375             assertEquals("max value @ level 3", END_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 376             quark = ssq.getQuarkRelative(maxMipmapQuark, String.valueOf(4));
 377             assertEquals("max value @ level 4", END_TIME / INTERVAL, intervals.get(quark).getStateValue().unboxLong());
 378
 379             int minMipmapQuark = ssq.getQuarkRelative(baseQuark, AbstractTmfMipmapStateProvider.MIN_STRING);
 380             assertEquals("min nblevels", NB_LEVELS, intervals.get(minMipmapQuark).getStateValue().unboxInt());
 381             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(1));
 382             assertEquals("min value @ level 1", END_TIME / INTERVAL - (END_TIME - START_TIME) / INTERVAL % (long) Math.pow(RESOLUTION, 1), intervals.get(quark).getStateValue().unboxLong());
 383             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(2));
 384             assertEquals("min value @ level 2", END_TIME / INTERVAL - (END_TIME - START_TIME) / INTERVAL % (long) Math.pow(RESOLUTION, 2), intervals.get(quark).getStateValue().unboxLong());
 385             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(3));
 386             assertEquals("min value @ level 3", END_TIME / INTERVAL - (END_TIME - START_TIME) / INTERVAL % (long) Math.pow(RESOLUTION, 3), intervals.get(quark).getStateValue().unboxLong());
 387             quark = ssq.getQuarkRelative(minMipmapQuark, String.valueOf(4));
 388             assertEquals("min value @ level 4", END_TIME / INTERVAL - (END_TIME - START_TIME) / INTERVAL % (long) Math.pow(RESOLUTION, 4), intervals.get(quark).getStateValue().unboxLong());
 389
 390             int avgMipmapQuark = ssq.getQuarkRelative(baseQuark, AbstractTmfMipmapStateProvider.AVG_STRING);
 391             assertEquals("avg nblevels", NB_LEVELS, intervals.get(avgMipmapQuark).getStateValue().unboxInt());
 392             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(1));
 393             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);
 394             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(2));
 395             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);
 396             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(3));
 397             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);
 398             quark = ssq.getQuarkRelative(avgMipmapQuark, String.valueOf(4));
 399             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);
 400
 401         } catch (TimeRangeException e) {
 402             fail(e.getMessage());
 403         } catch (StateSystemDisposedException e) {
 404             fail(e.getMessage());
 405         } catch (AttributeNotFoundException e) {
 406             fail(e.getMessage());
 407         } catch (StateValueTypeException e) {
 408             fail(e.getMessage());
 409         }
 410         assertTrue(true);
 411     }
 412
 413     /**
 414      * Test a query range to the state system to get the maximum value in the
 415      * range
 416      *
 417      * Make sure the state system has data.
 418      *
 419      *
 420      */
 421     @Test
 422     public void testQueryMipmapRangeMax() {
 423         assertNotNull(ssq);
 424         try {
 425             long max;
 426             int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 427
 428             max = TmfStateSystemOperations.queryRangeMax(ssq, 0, START_TIME, quark).unboxLong();
 429             assertEquals(START_TIME / INTERVAL, max);
 430
 431             max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, START_TIME, quark).unboxLong();
 432             assertEquals(START_TIME / INTERVAL, max);
 433
 434             max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, END_TIME / 2, quark).unboxLong();
 435             assertEquals((END_TIME / 2 / INTERVAL), max);
 436
 437             max = TmfStateSystemOperations.queryRangeMax(ssq, 0, END_TIME, quark).unboxLong();
 438             assertEquals(END_TIME / INTERVAL, max);
 439
 440             max = TmfStateSystemOperations.queryRangeMax(ssq, END_TIME / 2, END_TIME, quark).unboxLong();
 441             assertEquals(END_TIME / INTERVAL, max);
 442
 443             max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
 444             assertEquals(END_TIME / 2 / INTERVAL, max);
 445
 446         } catch (AttributeNotFoundException e) {
 447             fail(e.getMessage());
 448         } catch (StateValueTypeException e) {
 449             fail(e.getMessage());
 450         } catch (TimeRangeException e) {
 451             fail(e.getMessage());
 452         }
 453     }
 454
 455     /**
 456      * Test a query range to the state system to get the minimum value in the
 457      * range
 458      *
 459      * Make sure the state system has data.
 460      *
 461      *
 462      */
 463     @Test
 464     public void testQueryMipmapRangeMin() {
 465         assertNotNull(ssq);
 466         try {
 467             long min;
 468             int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 469
 470             min = TmfStateSystemOperations.queryRangeMin(ssq, 0, START_TIME, quark).unboxLong();
 471             assertEquals(START_TIME / INTERVAL, min);
 472
 473             min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, START_TIME, quark).unboxLong();
 474             assertEquals(START_TIME / INTERVAL, min);
 475
 476             min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, END_TIME / 2, quark).unboxLong();
 477             assertEquals((START_TIME / INTERVAL), min);
 478
 479             min = TmfStateSystemOperations.queryRangeMin(ssq, 0, END_TIME, quark).unboxLong();
 480             assertEquals(START_TIME / INTERVAL, min);
 481
 482             min = TmfStateSystemOperations.queryRangeMin(ssq, END_TIME / 2, END_TIME, quark).unboxLong();
 483             assertEquals(END_TIME / 2 / INTERVAL, min);
 484
 485             min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
 486             assertEquals(START_TIME / INTERVAL, min);
 487
 488         } catch (AttributeNotFoundException e) {
 489             fail(e.getMessage());
 490         } catch (StateValueTypeException e) {
 491             fail(e.getMessage());
 492         } catch (TimeRangeException e) {
 493             fail(e.getMessage());
 494         }
 495     }
 496
 497     /**
 498      * Test a query range to the state system to get the average value in the
 499      * range
 500      *
 501      * Make sure the state system has data.
 502      *
 503      */
 504     @Test
 505     public void testQueryMipmapRangeAvg() {
 506         assertNotNull(ssq);
 507         try {
 508             double avg;
 509             int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 510
 511             avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, START_TIME, quark);
 512             assertEquals((double) (START_TIME - INTERVAL) / INTERVAL, avg, DELTA);
 513
 514             avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, START_TIME, quark);
 515             assertEquals((double) START_TIME / INTERVAL, avg, DELTA);
 516
 517             avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, END_TIME / 2, quark);
 518             assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
 519
 520             avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, END_TIME, quark);
 521             assertEquals((double) (END_TIME - INTERVAL) / 2 / INTERVAL, avg, DELTA);
 522
 523             avg = TmfStateSystemOperations.queryRangeAverage(ssq, END_TIME / 2, END_TIME, quark);
 524             assertEquals((double) (END_TIME / 2 + (END_TIME - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
 525
 526             avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark);
 527             assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
 528
 529         } catch (AttributeNotFoundException e) {
 530             fail(e.getMessage());
 531         } catch (TimeRangeException e) {
 532             fail(e.getMessage());
 533         } catch (StateValueTypeException e) {
 534             fail(e.getMessage());
 535         }
 536     }
 537 }