org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.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  *     Patrick Tasse - Updates to mipmap feature
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.core.tests.statesystem.mipmap;
  14
  15 import static org.junit.Assert.assertEquals;
  16 import static org.junit.Assert.assertNotNull;
  17 import static org.junit.Assert.fail;
  18
  19 import org.eclipse.jdt.annotation.NonNull;
  20 import org.eclipse.linuxtools.internal.tmf.core.statesystem.StateSystem;
  21 import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend;
  22 import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.InMemoryBackend;
  23 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  24 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  25 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  26 import org.eclipse.linuxtools.tmf.core.statesystem.TmfStateSystemOperations;
  27 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue.Type;
  28 import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue;
  29 import org.junit.BeforeClass;
  30 import org.junit.Test;
  31
  32 /**
  33  * @author Patrick Tasse
  34  *
  35  */
  36 public class TmfMipmapStateProviderWeightedTest {
  37
  38     @NonNull private static final String SSID = "mipmap-test";
  39     private static final String TEST_ATTRIBUTE_NAME = TmfMipmapStateProviderStub.TEST_ATTRIBUTE_NAME;
  40     private static final long END_TIME = 250000L;
  41     private static final long INTERVAL = 1000L;
  42     private static final int RESOLUTION = 2;
  43     private static final double DELTA = 0.0001;
  44     private static StateSystem ssqi;
  45     private static StateSystem ssqd;
  46
  47     /**
  48      * Startup code, build a state system with uneven state durations
  49      */
  50     @BeforeClass
  51     public static void init() {
  52         /* setup for INTEGER test */
  53         TmfMipmapStateProviderStub mmpi = new TmfMipmapStateProviderStub(RESOLUTION, Type.INTEGER);
  54         IStateHistoryBackend bei = new InMemoryBackend(0);
  55         ssqi = new StateSystem(SSID, bei);
  56         mmpi.assignTargetStateSystem(ssqi);
  57         /* setup for DOUBLE test */
  58         TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE);
  59         IStateHistoryBackend bed = new InMemoryBackend(0);
  60         ssqd = new StateSystem(SSID, bed);
  61         mmpd.assignTargetStateSystem(ssqd);
  62         /*
  63          * Every 10,000 ns chunk contains the following states:
  64          *
  65          * | null |  10  | null |      20     | null |        30          | null |
  66          * 0     1000   2000   3000   4000   5000   6000   7000   8000   9000  10,000
  67          *
  68          * The weighted average for a chunk is (1 x 10 + 2 x 20 + 3 x 30) / 10 = 14.
  69          */
  70         for (int i = 0; i < END_TIME / INTERVAL / 10; i++) {
  71             long time = i * 10 * INTERVAL;
  72             /* update for INTEGER test */
  73             mmpi.processEvent(mmpi.createEvent(time, null));
  74             mmpi.processEvent(mmpi.createEvent(time + 1000, 10L));
  75             mmpi.processEvent(mmpi.createEvent(time + 2000, null));
  76             mmpi.processEvent(mmpi.createEvent(time + 3000, 20L));
  77             mmpi.processEvent(mmpi.createEvent(time + 5000, null));
  78             mmpi.processEvent(mmpi.createEvent(time + 6000, 30L));
  79             mmpi.processEvent(mmpi.createEvent(time + 9000, null));
  80             /* update for DOUBLE test */
  81             mmpd.processEvent(mmpd.createEvent(time, null));
  82             mmpd.processEvent(mmpd.createEvent(time + 1000, 10L));
  83             mmpd.processEvent(mmpd.createEvent(time + 2000, null));
  84             mmpd.processEvent(mmpd.createEvent(time + 3000, 20L));
  85             mmpd.processEvent(mmpd.createEvent(time + 5000, null));
  86             mmpd.processEvent(mmpd.createEvent(time + 6000, 30L));
  87             mmpd.processEvent(mmpd.createEvent(time + 9000, null));
  88         }
  89         /* cleanup for INTEGER test */
  90         mmpi.processEvent(mmpi.createEvent(END_TIME, 0L));
  91         mmpi.dispose();
  92         ssqi.waitUntilBuilt();
  93         /* cleanup for DOUBLE test */
  94         mmpd.processEvent(mmpd.createEvent(END_TIME, 0L));
  95         mmpd.dispose();
  96         ssqd.waitUntilBuilt();
  97     }
  98
  99     /**
 100      * Test a query range to the state system to get the maximum value in the
 101      * range. The test values are INTEGER.
 102      */
 103     @Test
 104     public void testQueryMipmapRangeMaxInteger() {
 105         assertNotNull(ssqi);
 106         try {
 107             int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 108             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 0, 0, quark));
 109             assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 500, 1500, quark).unboxInt());
 110             assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 1500, 5000, quark).unboxInt());
 111             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 5000, 10000, quark).unboxInt());
 112             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 10000, quark).unboxInt());
 113             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 120000, quark));
 114             assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 120500, 121500, quark).unboxInt());
 115             assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 121500, 125000, quark).unboxInt());
 116             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 125000, 130000, quark).unboxInt());
 117             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 130000, quark).unboxInt());
 118             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 100000, 150000, quark).unboxInt());
 119             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 240000, 250000, quark).unboxInt());
 120             assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 250000, quark).unboxInt());
 121             assertEquals(00, TmfStateSystemOperations.queryRangeMax(ssqi, 250000, 250000, quark).unboxInt());
 122
 123         } catch (AttributeNotFoundException e) {
 124             fail(e.getMessage());
 125         } catch (StateValueTypeException e) {
 126             fail(e.getMessage());
 127         } catch (TimeRangeException e) {
 128             fail(e.getMessage());
 129         }
 130     }
 131
 132     /**
 133      * Test a query range to the state system to get the minimum value in the
 134      * range. The test values are INTEGER.
 135      */
 136     @Test
 137     public void testQueryMipmapRangeMinInteger() {
 138         assertNotNull(ssqi);
 139         try {
 140             int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 141             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 0, 0, quark));
 142             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 500, 1500, quark).unboxInt());
 143             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 1500, 5000, quark).unboxInt());
 144             assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 5000, 10000, quark).unboxInt());
 145             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 10000, quark).unboxInt());
 146             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 120000, quark));
 147             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120500, 121500, quark).unboxInt());
 148             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 121500, 125000, quark).unboxInt());
 149             assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 125000, 130000, quark).unboxInt());
 150             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 130000, quark).unboxInt());
 151             assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 100000, 150000, quark).unboxInt());
 152             assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 240000, 250000, quark).unboxInt());
 153             assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 250000, quark).unboxInt());
 154             assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 250000, 250000, quark).unboxInt());
 155
 156         } catch (AttributeNotFoundException e) {
 157             fail(e.getMessage());
 158         } catch (StateValueTypeException e) {
 159             fail(e.getMessage());
 160         } catch (TimeRangeException e) {
 161             fail(e.getMessage());
 162         }
 163     }
 164
 165     /**
 166      * Test a query range to the state system to get the average value in the
 167      * range. The test values are INTEGER.
 168      */
 169     @Test
 170     public void testQueryMipmapRangeAvgInteger() {
 171         assertNotNull(ssqi);
 172         try {
 173             int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 174             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 0, quark), DELTA);
 175             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 1500, quark), DELTA);
 176             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 1500, 5000, quark), DELTA);
 177             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 10000, quark), DELTA);
 178             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 10000, quark), DELTA);
 179             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 20000, quark), DELTA);
 180             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 20500, quark), DELTA);
 181             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 1000, 21000, quark), DELTA);
 182             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 2000, 22000, quark), DELTA);
 183             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 3000, 23000, quark), DELTA);
 184             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 4000, 24000, quark), DELTA);
 185             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 25000, quark), DELTA);
 186             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 120000, quark), DELTA);
 187             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120500, 121500, quark), DELTA);
 188             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 121500, 125000, quark), DELTA);
 189             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 125000, 130000, quark), DELTA);
 190             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 130000, quark), DELTA);
 191             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 100000, 150000, quark), DELTA);
 192             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 240000, 250000, quark), DELTA);
 193             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 250000, quark), DELTA);
 194             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 250000, 250000, quark), DELTA);
 195
 196         } catch (AttributeNotFoundException e) {
 197             fail(e.getMessage());
 198         } catch (TimeRangeException e) {
 199             fail(e.getMessage());
 200         } catch (StateValueTypeException e) {
 201             fail(e.getMessage());
 202         }
 203     }
 204
 205     /**
 206      * Test a query range to the state system to get the maximum value in the
 207      * range. The test values are DOUBLE.
 208      */
 209     @Test
 210     public void testQueryMipmapRangeMaxDouble() {
 211         assertNotNull(ssqd);
 212         try {
 213             int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 214             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 0, 0, quark));
 215             assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 500, 1500, quark).unboxDouble(), DELTA);
 216             assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 1500, 5000, quark).unboxDouble(), DELTA);
 217             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 5000, 10000, quark).unboxDouble(), DELTA);
 218             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 10000, quark).unboxDouble(), DELTA);
 219             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 120000, quark));
 220             assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120500, 121500, quark).unboxDouble(), DELTA);
 221             assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 121500, 125000, quark).unboxDouble(), DELTA);
 222             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 125000, 130000, quark).unboxDouble(), DELTA);
 223             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 130000, quark).unboxDouble(), DELTA);
 224             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 100000, 150000, quark).unboxDouble(), DELTA);
 225             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 240000, 250000, quark).unboxDouble(), DELTA);
 226             assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 250000, quark).unboxDouble(), DELTA);
 227             assertEquals(00.0, TmfStateSystemOperations.queryRangeMax(ssqd, 250000, 250000, quark).unboxDouble(), DELTA);
 228
 229         } catch (AttributeNotFoundException e) {
 230             fail(e.getMessage());
 231         } catch (StateValueTypeException e) {
 232             fail(e.getMessage());
 233         } catch (TimeRangeException e) {
 234             fail(e.getMessage());
 235         }
 236     }
 237
 238     /**
 239      * Test a query range to the state system to get the minimum value in the
 240      * range. The test values are DOUBLE.
 241      */
 242     @Test
 243     public void testQueryMipmapRangeMinDouble() {
 244         assertNotNull(ssqd);
 245         try {
 246             int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 247             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 0, 0, quark));
 248             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 500, 1500, quark).unboxDouble(), DELTA);
 249             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 1500, 5000, quark).unboxDouble(), DELTA);
 250             assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 5000, 10000, quark).unboxDouble(), DELTA);
 251             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 10000, quark).unboxDouble(), DELTA);
 252             assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 120000, quark));
 253             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120500, 121500, quark).unboxDouble(), DELTA);
 254             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 121500, 125000, quark).unboxDouble(), DELTA);
 255             assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 125000, 130000, quark).unboxDouble(), DELTA);
 256             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 130000, quark).unboxDouble(), DELTA);
 257             assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 100000, 150000, quark).unboxDouble(), DELTA);
 258             assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 240000, 250000, quark).unboxDouble(), DELTA);
 259             assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 250000, quark).unboxDouble(), DELTA);
 260             assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 250000, 250000, quark).unboxDouble(), DELTA);
 261
 262         } catch (AttributeNotFoundException e) {
 263             fail(e.getMessage());
 264         } catch (StateValueTypeException e) {
 265             fail(e.getMessage());
 266         } catch (TimeRangeException e) {
 267             fail(e.getMessage());
 268         }
 269     }
 270
 271     /**
 272      * Test a query range to the state system to get the average value in the
 273      * range. The test values are DOUBLE.
 274      */
 275     @Test
 276     public void testQueryMipmapRangeAvgDouble() {
 277         assertNotNull(ssqd);
 278         try {
 279             int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
 280             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 0, quark), DELTA);
 281             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 1500, quark), DELTA);
 282             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 1500, 5000, quark), DELTA);
 283             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 10000, quark), DELTA);
 284             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 10000, quark), DELTA);
 285             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 20000, quark), DELTA);
 286             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 20500, quark), DELTA);
 287             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 1000, 21000, quark), DELTA);
 288             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 2000, 22000, quark), DELTA);
 289             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 3000, 23000, quark), DELTA);
 290             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 4000, 24000, quark), DELTA);
 291             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 25000, quark), DELTA);
 292             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 120000, quark), DELTA);
 293             assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120500, 121500, quark), DELTA);
 294             assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 121500, 125000, quark), DELTA);
 295             assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 125000, 130000, quark), DELTA);
 296             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 130000, quark), DELTA);
 297             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 100000, 150000, quark), DELTA);
 298             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 240000, 250000, quark), DELTA);
 299             assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 250000, quark), DELTA);
 300             assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 250000, 250000, quark), DELTA);
 301
 302         } catch (AttributeNotFoundException e) {
 303             fail(e.getMessage());
 304         } catch (TimeRangeException e) {
 305             fail(e.getMessage());
 306         } catch (StateValueTypeException e) {
 307             fail(e.getMessage());
 308         }
 309     }
 310 }