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