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

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 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.tracecompass.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.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;
  40
  41 /**
  42  * @author Jean-Christian Kouamé
  43  *
  44  */
  45 public class TmfMipmapStateProviderTest {
  46
  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;
  57
  58     /**
  59      * Startup code, build a state system with n attributes always going up
  60      * linearly
  61      */
  62     @BeforeClass
  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);
  68         ssq = ssb;
  69
  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);
  74         }
  75         mmp.dispose();
  76         ssq.waitUntilBuilt();
  77     }
  78
  79     /**
  80      * Test a single query to the state system.
  81      *
  82      * Make sure the state system has data.
  83      *
  84      * Hint: the value read should always be t / 1000
  85      *
  86      */
  87     @Test
  88     public void testQuery() {
  89         assertNotNull(ssq);
  90         try {
  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);
  98
  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());
 107         }
 108         assertTrue(true);
 109     }
 110
 111     /**
 112      * Test a single query to the state system for the maxLevel.
 113      *
 114      * Make sure the state system has data.
 115      *
 116      */
 117     @Test
 118     public void testMaxLevel() {
 119         assertNotNull(ssq);
 120         try {
 121             Random rn = new Random();
 122             long time = Math.max(INTERVAL, rn.nextLong() % END_TIME);
 123             List<ITmfStateInterval> intervals = ssq.queryFullState(time);
 124
 125             int maxMipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MAX_STRING);
 126             int nbLevelMax = intervals.get(maxMipmapQuark).getStateValue().unboxInt();
 127             assertEquals(NB_LEVELS, nbLevelMax);
 128
 129             int minMipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MIN_STRING);
 130             int nbLevelMin = intervals.get(minMipmapQuark).getStateValue().unboxInt();
 131             assertEquals(NB_LEVELS, nbLevelMin);
 132
 133             int avgMipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.AVG_STRING);
 134             int nbLevelAvg = intervals.get(avgMipmapQuark).getStateValue().unboxInt();
 135             assertEquals(NB_LEVELS, nbLevelAvg);
 136
 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());
 145         }
 146         assertTrue(true);
 147
 148     }
 149
 150     /**
 151      * Test a single query to the state system for a mip
 152      *
 153      * Make sure the state system has data.
 154      *
 155      */
 156     @Test
 157     public void testQueryEventField() {
 158         assertNotNull(ssq);
 159         try {
 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());
 173         }
 174         assertTrue(true);
 175     }
 176
 177     /**
 178      * Test a single query to the state system for a max
 179      *
 180      * Make sure the state system has data.
 181      *
 182      * Hint: the value read should always be greater than(t / 1000)
 183      *
 184      */
 185     @Test
 186     public void testQueryMipMax() {
 187         assertNotNull(ssq);
 188         try {
 189             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 190             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MAX_STRING);
 191
 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);
 201             }
 202
 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());
 211         }
 212         assertTrue(true);
 213     }
 214
 215     /**
 216      * Test a single query to the state system for a min
 217      *
 218      * Make sure the state system has data.
 219      *
 220      * Hint: the value read should always be less than(t / 1000)
 221      */
 222     @Test
 223     public void testQueryMipMin() {
 224         assertNotNull(ssq);
 225         try {
 226             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 227             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.MIN_STRING);
 228
 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);
 238             }
 239
 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());
 248         }
 249         assertTrue(true);
 250     }
 251
 252     /**
 253      * Test a single query to the state system for an average
 254      *
 255      * Make sure the state system has data.
 256      *
 257      * Hint: the value read should always be more or less(t / 1000)
 258      *
 259      */
 260     @Test
 261     public void testQueryMipAvg() {
 262         assertNotNull(ssq);
 263         try {
 264             List<ITmfStateInterval> intervals = ssq.queryFullState(TEST_TIMESTAMP);
 265             int mipmapQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME, AbstractTmfMipmapStateProvider.AVG_STRING);
 266
 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);
 276             }
 277
 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());
 286         }
 287         assertTrue(true);
 288     }
 289
 290     /**
 291      * Test a full query to the state system at the startTime
 292      *
 293      * Make sure the state system has data.
 294      *
 295      * Hint: the value read should always be more or less(t / 1000)
 296      *
 297      */
 298     @Test
 299     public void testQueryValuesOnStart() {
 300         assertNotNull(ssq);
 301         try {
 302             int quark;
 303
 304             List<ITmfStateInterval> intervals = ssq.queryFullState(START_TIME);
 305
 306             int baseQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 307             assertEquals(START_TIME / INTERVAL, intervals.get(baseQuark).getStateValue().unboxLong());
 308
 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());
 319
 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());
 330
 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);
 341
 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());
 350         }
 351         assertTrue(true);
 352     }
 353
 354     /**
 355      * Test a full query to the state system when the end time
 356      *
 357      * Make sure the state system has data.
 358      *
 359      * Hint: the value read should always be more or less(t / 1000)
 360      *
 361      */
 362     @Test
 363     public void testQueryValuesOnClose() {
 364         assertNotNull(ssq);
 365         try {
 366             int quark;
 367
 368             List<ITmfStateInterval> intervals = ssq.queryFullState(END_TIME);
 369
 370             int baseQuark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 371             assertEquals(END_TIME / INTERVAL, intervals.get(baseQuark).getStateValue().unboxLong());
 372
 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());
 383
 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());
 394
 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);
 405
 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());
 414         }
 415         assertTrue(true);
 416     }
 417
 418     /**
 419      * Test a query range to the state system to get the maximum value in the
 420      * range
 421      *
 422      * Make sure the state system has data.
 423      *
 424      *
 425      */
 426     @Test
 427     public void testQueryMipmapRangeMax() {
 428         assertNotNull(ssq);
 429         try {
 430             long max;
 431             int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 432
 433             max = TmfStateSystemOperations.queryRangeMax(ssq, 0, START_TIME, quark).unboxLong();
 434             assertEquals(START_TIME / INTERVAL, max);
 435
 436             max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, START_TIME, quark).unboxLong();
 437             assertEquals(START_TIME / INTERVAL, max);
 438
 439             max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, END_TIME / 2, quark).unboxLong();
 440             assertEquals((END_TIME / 2 / INTERVAL), max);
 441
 442             max = TmfStateSystemOperations.queryRangeMax(ssq, 0, END_TIME, quark).unboxLong();
 443             assertEquals(END_TIME / INTERVAL, max);
 444
 445             max = TmfStateSystemOperations.queryRangeMax(ssq, END_TIME / 2, END_TIME, quark).unboxLong();
 446             assertEquals(END_TIME / INTERVAL, max);
 447
 448             max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
 449             assertEquals(END_TIME / 2 / INTERVAL, max);
 450
 451         } catch (AttributeNotFoundException e) {
 452             fail(e.getMessage());
 453         } catch (StateValueTypeException e) {
 454             fail(e.getMessage());
 455         } catch (TimeRangeException e) {
 456             fail(e.getMessage());
 457         }
 458     }
 459
 460     /**
 461      * Test a query range to the state system to get the minimum value in the
 462      * range
 463      *
 464      * Make sure the state system has data.
 465      *
 466      *
 467      */
 468     @Test
 469     public void testQueryMipmapRangeMin() {
 470         assertNotNull(ssq);
 471         try {
 472             long min;
 473             int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 474
 475             min = TmfStateSystemOperations.queryRangeMin(ssq, 0, START_TIME, quark).unboxLong();
 476             assertEquals(START_TIME / INTERVAL, min);
 477
 478             min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, START_TIME, quark).unboxLong();
 479             assertEquals(START_TIME / INTERVAL, min);
 480
 481             min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, END_TIME / 2, quark).unboxLong();
 482             assertEquals((START_TIME / INTERVAL), min);
 483
 484             min = TmfStateSystemOperations.queryRangeMin(ssq, 0, END_TIME, quark).unboxLong();
 485             assertEquals(START_TIME / INTERVAL, min);
 486
 487             min = TmfStateSystemOperations.queryRangeMin(ssq, END_TIME / 2, END_TIME, quark).unboxLong();
 488             assertEquals(END_TIME / 2 / INTERVAL, min);
 489
 490             min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
 491             assertEquals(START_TIME / INTERVAL, min);
 492
 493         } catch (AttributeNotFoundException e) {
 494             fail(e.getMessage());
 495         } catch (StateValueTypeException e) {
 496             fail(e.getMessage());
 497         } catch (TimeRangeException e) {
 498             fail(e.getMessage());
 499         }
 500     }
 501
 502     /**
 503      * Test a query range to the state system to get the average value in the
 504      * range
 505      *
 506      * Make sure the state system has data.
 507      *
 508      */
 509     @Test
 510     public void testQueryMipmapRangeAvg() {
 511         assertNotNull(ssq);
 512         try {
 513             double avg;
 514             int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 515
 516             avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, START_TIME, quark);
 517             assertEquals((double) (START_TIME - INTERVAL) / INTERVAL, avg, DELTA);
 518
 519             avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, START_TIME, quark);
 520             assertEquals((double) START_TIME / INTERVAL, avg, DELTA);
 521
 522             avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, END_TIME / 2, quark);
 523             assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
 524
 525             avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, END_TIME, quark);
 526             assertEquals((double) (END_TIME - INTERVAL) / 2 / INTERVAL, avg, DELTA);
 527
 528             avg = TmfStateSystemOperations.queryRangeAverage(ssq, END_TIME / 2, END_TIME, quark);
 529             assertEquals((double) (END_TIME / 2 + (END_TIME - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
 530
 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);
 533
 534         } catch (AttributeNotFoundException e) {
 535             fail(e.getMessage());
 536         } catch (TimeRangeException e) {
 537             fail(e.getMessage());
 538         } catch (StateValueTypeException e) {
 539             fail(e.getMessage());
 540         }
 541     }
 542 }