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