private static final double DELTA = 0.0001;
private static final long TEST_TIMESTAMP = 12345000L;
private static StateSystem ssq;
- private static TmfStateSystemOperations sso;
/**
* Startup code, build a state system with n attributes always going up
TmfMipmapStateProviderStub mmp = new TmfMipmapStateProviderStub(RESOLUTION, Type.LONG);
IStateHistoryBackend be = new InMemoryBackend(0);
ssq = new StateSystem(be);
- sso = new TmfStateSystemOperations(ssq);
mmp.assignTargetStateSystem(ssq);
for (long time = START_TIME; time <= END_TIME; time += INTERVAL) {
long max;
int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- max = sso.queryRangeMax(0, START_TIME, quark).unboxLong();
+ max = TmfStateSystemOperations.queryRangeMax(ssq, 0, START_TIME, quark).unboxLong();
assertEquals(START_TIME / INTERVAL, max);
- max = sso.queryRangeMax(START_TIME, START_TIME, quark).unboxLong();
+ max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, START_TIME, quark).unboxLong();
assertEquals(START_TIME / INTERVAL, max);
- max = sso.queryRangeMax(START_TIME, END_TIME / 2, quark).unboxLong();
+ max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, END_TIME / 2, quark).unboxLong();
assertEquals((END_TIME / 2 / INTERVAL), max);
- max = sso.queryRangeMax(0, END_TIME, quark).unboxLong();
+ max = TmfStateSystemOperations.queryRangeMax(ssq, 0, END_TIME, quark).unboxLong();
assertEquals(END_TIME / INTERVAL, max);
- max = sso.queryRangeMax(END_TIME / 2, END_TIME, quark).unboxLong();
+ max = TmfStateSystemOperations.queryRangeMax(ssq, END_TIME / 2, END_TIME, quark).unboxLong();
assertEquals(END_TIME / INTERVAL, max);
- max = sso.queryRangeMax(START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
+ max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
assertEquals(END_TIME / 2 / INTERVAL, max);
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
} catch (StateValueTypeException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
}
}
long min;
int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- min = sso.queryRangeMin(0, START_TIME, quark).unboxLong();
+ min = TmfStateSystemOperations.queryRangeMin(ssq, 0, START_TIME, quark).unboxLong();
assertEquals(START_TIME / INTERVAL, min);
- min = sso.queryRangeMin(START_TIME, START_TIME, quark).unboxLong();
+ min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, START_TIME, quark).unboxLong();
assertEquals(START_TIME / INTERVAL, min);
- min = sso.queryRangeMin(START_TIME, END_TIME / 2, quark).unboxLong();
+ min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, END_TIME / 2, quark).unboxLong();
assertEquals((START_TIME / INTERVAL), min);
- min = sso.queryRangeMin(0, END_TIME, quark).unboxLong();
+ min = TmfStateSystemOperations.queryRangeMin(ssq, 0, END_TIME, quark).unboxLong();
assertEquals(START_TIME / INTERVAL, min);
- min = sso.queryRangeMin(END_TIME / 2, END_TIME, quark).unboxLong();
+ min = TmfStateSystemOperations.queryRangeMin(ssq, END_TIME / 2, END_TIME, quark).unboxLong();
assertEquals(END_TIME / 2 / INTERVAL, min);
- min = sso.queryRangeMin(START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
+ min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong();
assertEquals(START_TIME / INTERVAL, min);
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
} catch (StateValueTypeException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
}
}
double avg;
int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- avg = sso.queryRangeAverage(0, START_TIME, quark);
+ avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, START_TIME, quark);
assertEquals((double) (START_TIME - INTERVAL) / INTERVAL, avg, DELTA);
- avg = sso.queryRangeAverage(START_TIME, START_TIME, quark);
+ avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, START_TIME, quark);
assertEquals((double) START_TIME / INTERVAL, avg, DELTA);
- avg = sso.queryRangeAverage(START_TIME, END_TIME / 2, quark);
+ avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, END_TIME / 2, quark);
assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
- avg = sso.queryRangeAverage(0, END_TIME, quark);
+ avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, END_TIME, quark);
assertEquals((double) (END_TIME - INTERVAL) / 2 / INTERVAL, avg, DELTA);
- avg = sso.queryRangeAverage(END_TIME / 2, END_TIME, quark);
+ avg = TmfStateSystemOperations.queryRangeAverage(ssq, END_TIME / 2, END_TIME, quark);
assertEquals((double) (END_TIME / 2 + (END_TIME - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
- avg = sso.queryRangeAverage(START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark);
+ avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark);
assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA);
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
+ } catch (StateValueTypeException e) {
+ fail(e.getMessage());
}
}
}
import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.InMemoryBackend;
import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
+import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
import org.eclipse.linuxtools.tmf.core.statesystem.TmfStateSystemOperations;
import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue.Type;
import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue;
private static final double DELTA = 0.0001;
private static StateSystem ssqi;
private static StateSystem ssqd;
- private static TmfStateSystemOperations ssoi;
- private static TmfStateSystemOperations ssod;
/**
* Startup code, build a state system with uneven state durations
TmfMipmapStateProviderStub mmpi = new TmfMipmapStateProviderStub(RESOLUTION, Type.INTEGER);
IStateHistoryBackend bei = new InMemoryBackend(0);
ssqi = new StateSystem(bei);
- ssoi = new TmfStateSystemOperations(ssqi);
mmpi.assignTargetStateSystem(ssqi);
/* setup for DOUBLE test */
TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE);
IStateHistoryBackend bed = new InMemoryBackend(0);
ssqd = new StateSystem(bed);
- ssod = new TmfStateSystemOperations(ssqd);
mmpd.assignTargetStateSystem(ssqd);
/*
* Every 10,000 ns chunk contains the following states:
assertNotNull(ssqi);
try {
int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMax(0, 0, quark));
- assertEquals(10, ssoi.queryRangeMax(500, 1500, quark).unboxInt());
- assertEquals(20, ssoi.queryRangeMax(1500, 5000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(5000, 10000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(0, 10000, quark).unboxInt());
- assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMax(120000, 120000, quark));
- assertEquals(10, ssoi.queryRangeMax(120500, 121500, quark).unboxInt());
- assertEquals(20, ssoi.queryRangeMax(121500, 125000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(125000, 130000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(120000, 130000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(100000, 150000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(240000, 250000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMax(0, 250000, quark).unboxInt());
- assertEquals(00, ssoi.queryRangeMax(250000, 250000, quark).unboxInt());
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 0, 0, quark));
+ assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 500, 1500, quark).unboxInt());
+ assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 1500, 5000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 5000, 10000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 10000, quark).unboxInt());
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 120000, quark));
+ assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 120500, 121500, quark).unboxInt());
+ assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 121500, 125000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 125000, 130000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 130000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 100000, 150000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 240000, 250000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 250000, quark).unboxInt());
+ assertEquals(00, TmfStateSystemOperations.queryRangeMax(ssqi, 250000, 250000, quark).unboxInt());
+
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
} catch (StateValueTypeException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
}
}
assertNotNull(ssqi);
try {
int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMin(0, 0, quark));
- assertEquals(10, ssoi.queryRangeMin(500, 1500, quark).unboxInt());
- assertEquals(10, ssoi.queryRangeMin(1500, 5000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMin(5000, 10000, quark).unboxInt());
- assertEquals(10, ssoi.queryRangeMin(0, 10000, quark).unboxInt());
- assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMin(120000, 120000, quark));
- assertEquals(10, ssoi.queryRangeMin(120500, 121500, quark).unboxInt());
- assertEquals(10, ssoi.queryRangeMin(121500, 125000, quark).unboxInt());
- assertEquals(30, ssoi.queryRangeMin(125000, 130000, quark).unboxInt());
- assertEquals(10, ssoi.queryRangeMin(120000, 130000, quark).unboxInt());
- assertEquals(10, ssoi.queryRangeMin(100000, 150000, quark).unboxInt());
- assertEquals(00, ssoi.queryRangeMin(240000, 250000, quark).unboxInt());
- assertEquals(00, ssoi.queryRangeMin(0, 250000, quark).unboxInt());
- assertEquals(00, ssoi.queryRangeMin(250000, 250000, quark).unboxInt());
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 0, 0, quark));
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 500, 1500, quark).unboxInt());
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 1500, 5000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 5000, 10000, quark).unboxInt());
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 10000, quark).unboxInt());
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 120000, quark));
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120500, 121500, quark).unboxInt());
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 121500, 125000, quark).unboxInt());
+ assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 125000, 130000, quark).unboxInt());
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 130000, quark).unboxInt());
+ assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 100000, 150000, quark).unboxInt());
+ assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 240000, 250000, quark).unboxInt());
+ assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 250000, quark).unboxInt());
+ assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 250000, 250000, quark).unboxInt());
+
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
} catch (StateValueTypeException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
}
}
assertNotNull(ssqi);
try {
int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- assertEquals(0.0, ssoi.queryRangeAverage(0, 0, quark), DELTA);
- assertEquals(5.0, ssoi.queryRangeAverage(500, 1500, quark), DELTA);
- assertEquals(90.0 / 7, ssoi.queryRangeAverage(1500, 5000, quark), DELTA);
- assertEquals(90.0 / 5, ssoi.queryRangeAverage(5000, 10000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(0, 10000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(0, 20000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(500, 20500, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(1000, 21000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(2000, 22000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(3000, 23000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(4000, 24000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(5000, 25000, quark), DELTA);
- assertEquals(0.0, ssoi.queryRangeAverage(120000, 120000, quark), DELTA);
- assertEquals(5.0, ssoi.queryRangeAverage(120500, 121500, quark), DELTA);
- assertEquals(90.0 / 7, ssoi.queryRangeAverage(121500, 125000, quark), DELTA);
- assertEquals(90.0 / 5, ssoi.queryRangeAverage(125000, 130000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(120000, 130000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(100000, 150000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(240000, 250000, quark), DELTA);
- assertEquals(14.0, ssoi.queryRangeAverage(0, 250000, quark), DELTA);
- assertEquals(0.0, ssoi.queryRangeAverage(250000, 250000, quark), DELTA);
+ assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 0, quark), DELTA);
+ assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 1500, quark), DELTA);
+ assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 1500, 5000, quark), DELTA);
+ assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 10000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 10000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 20000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 20500, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 1000, 21000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 2000, 22000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 3000, 23000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 4000, 24000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 25000, quark), DELTA);
+ assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 120000, quark), DELTA);
+ assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120500, 121500, quark), DELTA);
+ assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 121500, 125000, quark), DELTA);
+ assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 125000, 130000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 130000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 100000, 150000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 240000, 250000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 250000, quark), DELTA);
+ assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 250000, 250000, quark), DELTA);
+
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
+ } catch (StateValueTypeException e) {
+ fail(e.getMessage());
}
}
assertNotNull(ssqd);
try {
int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMax(0, 0, quark));
- assertEquals(10.0, ssod.queryRangeMax(500, 1500, quark).unboxDouble(), DELTA);
- assertEquals(20.0, ssod.queryRangeMax(1500, 5000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(5000, 10000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(0, 10000, quark).unboxDouble(), DELTA);
- assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMax(120000, 120000, quark));
- assertEquals(10.0, ssod.queryRangeMax(120500, 121500, quark).unboxDouble(), DELTA);
- assertEquals(20.0, ssod.queryRangeMax(121500, 125000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(125000, 130000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(120000, 130000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(100000, 150000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(240000, 250000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMax(0, 250000, quark).unboxDouble(), DELTA);
- assertEquals(00.0, ssod.queryRangeMax(250000, 250000, quark).unboxDouble(), DELTA);
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 0, 0, quark));
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 500, 1500, quark).unboxDouble(), DELTA);
+ assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 1500, 5000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 5000, 10000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 10000, quark).unboxDouble(), DELTA);
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 120000, quark));
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120500, 121500, quark).unboxDouble(), DELTA);
+ assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 121500, 125000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 125000, 130000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 130000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 100000, 150000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 240000, 250000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 250000, quark).unboxDouble(), DELTA);
+ assertEquals(00.0, TmfStateSystemOperations.queryRangeMax(ssqd, 250000, 250000, quark).unboxDouble(), DELTA);
+
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
} catch (StateValueTypeException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
}
}
assertNotNull(ssqd);
try {
int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMin(0, 0, quark));
- assertEquals(10.0, ssod.queryRangeMin(500, 1500, quark).unboxDouble(), DELTA);
- assertEquals(10.0, ssod.queryRangeMin(1500, 5000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMin(5000, 10000, quark).unboxDouble(), DELTA);
- assertEquals(10.0, ssod.queryRangeMin(0, 10000, quark).unboxDouble(), DELTA);
- assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMin(120000, 120000, quark));
- assertEquals(10.0, ssod.queryRangeMin(120500, 121500, quark).unboxDouble(), DELTA);
- assertEquals(10.0, ssod.queryRangeMin(121500, 125000, quark).unboxDouble(), DELTA);
- assertEquals(30.0, ssod.queryRangeMin(125000, 130000, quark).unboxDouble(), DELTA);
- assertEquals(10.0, ssod.queryRangeMin(120000, 130000, quark).unboxDouble(), DELTA);
- assertEquals(10.0, ssod.queryRangeMin(100000, 150000, quark).unboxDouble(), DELTA);
- assertEquals(00.0, ssod.queryRangeMin(240000, 250000, quark).unboxDouble(), DELTA);
- assertEquals(00.0, ssod.queryRangeMin(0, 250000, quark).unboxDouble(), DELTA);
- assertEquals(00.0, ssod.queryRangeMin(250000, 250000, quark).unboxDouble(), DELTA);
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 0, 0, quark));
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 500, 1500, quark).unboxDouble(), DELTA);
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 1500, 5000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 5000, 10000, quark).unboxDouble(), DELTA);
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 10000, quark).unboxDouble(), DELTA);
+ assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 120000, quark));
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120500, 121500, quark).unboxDouble(), DELTA);
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 121500, 125000, quark).unboxDouble(), DELTA);
+ assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 125000, 130000, quark).unboxDouble(), DELTA);
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 130000, quark).unboxDouble(), DELTA);
+ assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 100000, 150000, quark).unboxDouble(), DELTA);
+ assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 240000, 250000, quark).unboxDouble(), DELTA);
+ assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 250000, quark).unboxDouble(), DELTA);
+ assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 250000, 250000, quark).unboxDouble(), DELTA);
+
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
} catch (StateValueTypeException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
}
}
assertNotNull(ssqd);
try {
int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME);
- assertEquals(0.0, ssod.queryRangeAverage(0, 0, quark), DELTA);
- assertEquals(5.0, ssod.queryRangeAverage(500, 1500, quark), DELTA);
- assertEquals(90.0 / 7, ssod.queryRangeAverage(1500, 5000, quark), DELTA);
- assertEquals(90.0 / 5, ssod.queryRangeAverage(5000, 10000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(0, 10000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(0, 20000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(500, 20500, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(1000, 21000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(2000, 22000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(3000, 23000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(4000, 24000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(5000, 25000, quark), DELTA);
- assertEquals(0.0, ssod.queryRangeAverage(120000, 120000, quark), DELTA);
- assertEquals(5.0, ssod.queryRangeAverage(120500, 121500, quark), DELTA);
- assertEquals(90.0 / 7, ssod.queryRangeAverage(121500, 125000, quark), DELTA);
- assertEquals(90.0 / 5, ssod.queryRangeAverage(125000, 130000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(120000, 130000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(100000, 150000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(240000, 250000, quark), DELTA);
- assertEquals(14.0, ssod.queryRangeAverage(0, 250000, quark), DELTA);
- assertEquals(0.0, ssod.queryRangeAverage(250000, 250000, quark), DELTA);
+ assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 0, quark), DELTA);
+ assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 1500, quark), DELTA);
+ assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 1500, 5000, quark), DELTA);
+ assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 10000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 10000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 20000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 20500, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 1000, 21000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 2000, 22000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 3000, 23000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 4000, 24000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 25000, quark), DELTA);
+ assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 120000, quark), DELTA);
+ assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120500, 121500, quark), DELTA);
+ assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 121500, 125000, quark), DELTA);
+ assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 125000, 130000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 130000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 100000, 150000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 240000, 250000, quark), DELTA);
+ assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 250000, quark), DELTA);
+ assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 250000, 250000, quark), DELTA);
+
} catch (AttributeNotFoundException e) {
fail(e.getMessage());
+ } catch (TimeRangeException e) {
+ fail(e.getMessage());
+ } catch (StateValueTypeException e) {
+ fail(e.getMessage());
}
}
}
/**
* This class implements additional statistical operations that can be
* performed on attributes of the state system.
+ *
+ * @author Patrick Tassé
*/
-public class TmfStateSystemOperations {
-
- private final ITmfStateSystem ss;
+public final class TmfStateSystemOperations {
- /**
- * Constructor
- *
- * @param ss
- * The state system on which to perform operations
- */
- public TmfStateSystemOperations(ITmfStateSystem ss) {
- this.ss = ss;
- }
+ private TmfStateSystemOperations() {}
/**
* Return the maximum value of an attribute over a time range
*
+ * @param ss
+ * The state system to query
* @param t1
* The start time of the range
* @param t2
* @param quark
* The quark of the attribute
* @return The maximum value of the attribute in this range
+ * @throws TimeRangeException
+ * If an invalid time range is specified
+ * @throws AttributeNotFoundException
+ * If the specified quark doesn't match an attribute
+ * @throws StateValueTypeException
+ * If the state value type of the attribute does not support the
+ * "Max" operation
*/
- public ITmfStateValue queryRangeMax(long t1, long t2, int quark) {
+ public static ITmfStateValue queryRangeMax(ITmfStateSystem ss, long t1, long t2, int quark)
+ throws AttributeNotFoundException, TimeRangeException, StateValueTypeException {
ITmfStateValue max = TmfStateValue.nullValue();
- try {
- List<ITmfStateInterval> intervals = queryAttributeRange(t1, t2, quark, AbstractTmfMipmapStateProvider.MAX_STRING);
- if (intervals.size() == 0) {
- return TmfStateValue.nullValue();
- }
- for (ITmfStateInterval si : intervals) {
- ITmfStateValue value = si.getStateValue();
- if (value.getType() == Type.DOUBLE) {
- if (max.isNull() || si.getStateValue().unboxDouble() > max.unboxDouble()) {
- max = si.getStateValue();
- }
- } else {
- if (max.isNull() || si.getStateValue().unboxLong() > max.unboxLong()) {
- max = si.getStateValue();
- }
+
+ List<ITmfStateInterval> intervals = queryAttributeRange(ss, t1, t2, quark, AbstractTmfMipmapStateProvider.MAX_STRING);
+ if (intervals.size() == 0) {
+ return TmfStateValue.nullValue();
+ }
+ for (ITmfStateInterval si : intervals) {
+ ITmfStateValue value = si.getStateValue();
+
+ switch (value.getType()) {
+ case DOUBLE:
+ if (max.isNull() || si.getStateValue().unboxDouble() > max.unboxDouble()) {
+ max = si.getStateValue();
+ }
+ break;
+
+ case INTEGER:
+ case LONG:
+ if (max.isNull() || si.getStateValue().unboxLong() > max.unboxLong()) {
+ max = si.getStateValue();
}
+ break;
+
+ case NULL:
+ case STRING:
+ default:
+ throw new StateValueTypeException();
}
- } catch (StateValueTypeException e) {
- e.printStackTrace();
}
return max;
}
/**
* Return the minimum value of an attribute over a time range
*
+ * @param ss
+ * The state system to query
* @param t1
* The start time of the range
* @param t2
* @param quark
* The quark of the attribute
* @return The minimum value of the attribute in this range
+ * @throws TimeRangeException
+ * If an invalid time range is specified
+ * @throws AttributeNotFoundException
+ * If the specified quark doesn't match an attribute
+ * @throws StateValueTypeException
+ * If the state value type of the attribute does not support the
+ * "Min" operation
*/
- public ITmfStateValue queryRangeMin(long t1, long t2, int quark) {
+ public static ITmfStateValue queryRangeMin(ITmfStateSystem ss,
+ long t1, long t2, int quark)
+ throws AttributeNotFoundException, TimeRangeException, StateValueTypeException {
ITmfStateValue min = TmfStateValue.nullValue();
- try {
- List<ITmfStateInterval> intervals = queryAttributeRange(t1, t2, quark, AbstractTmfMipmapStateProvider.MIN_STRING);
- if (intervals.size() == 0) {
- return TmfStateValue.nullValue();
- }
- for (ITmfStateInterval si : intervals) {
- ITmfStateValue value = si.getStateValue();
- if (value.getType() == Type.DOUBLE) {
- if (min.isNull() || si.getStateValue().unboxDouble() < min.unboxDouble()) {
- min = si.getStateValue();
- }
- } else {
- if (min.isNull() || si.getStateValue().unboxLong() < min.unboxLong()) {
- min = si.getStateValue();
- }
+
+ List<ITmfStateInterval> intervals = queryAttributeRange(ss, t1, t2, quark, AbstractTmfMipmapStateProvider.MIN_STRING);
+ if (intervals.size() == 0) {
+ return TmfStateValue.nullValue();
+ }
+ for (ITmfStateInterval si : intervals) {
+ ITmfStateValue value = si.getStateValue();
+
+ switch (value.getType()) {
+ case DOUBLE:
+ if (min.isNull() || si.getStateValue().unboxDouble() < min.unboxDouble()) {
+ min = si.getStateValue();
+ }
+ break;
+
+ case INTEGER:
+ case LONG:
+ if (min.isNull() || si.getStateValue().unboxLong() < min.unboxLong()) {
+ min = si.getStateValue();
}
+ break;
+
+ case NULL:
+ case STRING:
+ default:
+ throw new StateValueTypeException();
}
- } catch (StateValueTypeException e) {
- e.printStackTrace();
}
return min;
}
/**
* Return the weighted average value of an attribute over a time range
*
+ * @param ss
+ * The state system to query
* @param t1
* The start time of the range
* @param t2
* @param quark
* The quark of the attribute
* @return The weighted average value of the attribute in this range
+ * @throws TimeRangeException
+ * If an invalid time range is specified
+ * @throws AttributeNotFoundException
+ * If the specified quark doesn't match an attribute
+ * @throws StateValueTypeException
+ * If the state value type of the attribute does not support the
+ * "Average" operation
*/
- public double queryRangeAverage(long t1, long t2, int quark) {
+ public static double queryRangeAverage(ITmfStateSystem ss, long t1, long t2, int quark)
+ throws AttributeNotFoundException, TimeRangeException, StateValueTypeException {
double avg = 0.0;
- try {
- List<ITmfStateInterval> intervals = queryAttributeRange(t1, t2, quark, AbstractTmfMipmapStateProvider.AVG_STRING);
- if (intervals.size() == 0) {
- return 0;
- } else if (t1 == t2) {
- ITmfStateValue value = intervals.get(0).getStateValue();
- if (value.getType() == Type.DOUBLE) {
- return value.unboxDouble();
- }
- return value.unboxLong();
+ List<ITmfStateInterval> intervals = queryAttributeRange(ss, t1, t2, quark, AbstractTmfMipmapStateProvider.AVG_STRING);
+ if (intervals.size() == 0) {
+ return 0;
+ } else if (t1 == t2) {
+ ITmfStateValue value = intervals.get(0).getStateValue();
+ if (value.getType() == Type.DOUBLE) {
+ return value.unboxDouble();
}
- for (ITmfStateInterval si : intervals) {
- long startTime = Math.max(t1, si.getStartTime());
- long endTime = Math.min(t2, si.getEndTime() + 1);
- long delta = endTime - startTime;
- if (delta > 0) {
- ITmfStateValue value = si.getStateValue();
- if (value.getType() == Type.DOUBLE) {
- avg += si.getStateValue().unboxDouble() * ((double) delta / (double) (t2 - t1));
- } else {
- avg += si.getStateValue().unboxLong() * ((double) delta / (double) (t2 - t1));
- }
+ return value.unboxLong();
+ }
+ for (ITmfStateInterval si : intervals) {
+ long startTime = Math.max(t1, si.getStartTime());
+ long endTime = Math.min(t2, si.getEndTime() + 1);
+ long delta = endTime - startTime;
+ if (delta > 0) {
+ ITmfStateValue value = si.getStateValue();
+ if (value.getType() == Type.DOUBLE) {
+ avg += si.getStateValue().unboxDouble() * ((double) delta / (double) (t2 - t1));
+ } else {
+ avg += si.getStateValue().unboxLong() * ((double) delta / (double) (t2 - t1));
}
}
- } catch (StateValueTypeException e) {
- e.printStackTrace();
}
return avg;
}
- private List<ITmfStateInterval> queryAttributeRange(long t1, long t2, int baseQuark, String featureString) {
+ private static List<ITmfStateInterval> queryAttributeRange(ITmfStateSystem ss,
+ long t1, long t2, int baseQuark, String featureString)
+ throws AttributeNotFoundException, TimeRangeException, StateValueTypeException {
Pair<Long, Long> timeRange = new Pair<Long, Long>(t1, t2);
int mipmapQuark = -1;
List<ITmfStateInterval> intervals = new ArrayList<ITmfStateInterval>();
}
ITmfStateInterval maxLevelInterval = ss.querySingleState(timeRange.getSecond(), mipmapQuark);
int levelMax = maxLevelInterval.getStateValue().unboxInt();
- queryMipmapAttributeRange(0, levelMax, baseQuark, mipmapQuark, timeRange, intervals);
+ queryMipmapAttributeRange(ss, 0, levelMax, baseQuark, mipmapQuark, timeRange, intervals);
return intervals;
- } catch (AttributeNotFoundException e) {
- e.printStackTrace();
- } catch (TimeRangeException e) {
- e.printStackTrace();
+
} catch (StateValueTypeException e) {
- e.printStackTrace();
+ /* This is a special case, so we'll add a message to the exception */
+ throw new StateValueTypeException("State system advertises mipmaps," + //$NON-NLS-1$
+ " but doesn't actually have them.", e); //$NON-NLS-1$
} catch (StateSystemDisposedException e) {
- /* Ignored */
+ /* We are shutting down, ignore the operation */
}
return intervals;
}
- private void queryMipmapAttributeRange(int currentLevel, int levelMax, int baseQuark, int mipmapQuark, Pair<Long, Long> timeRange, List<ITmfStateInterval> intervals) {
+ private static void queryMipmapAttributeRange(ITmfStateSystem ss,
+ int currentLevel, int levelMax, int baseQuark, int mipmapQuark,
+ Pair<Long, Long> timeRange, List<ITmfStateInterval> intervals)
+ throws AttributeNotFoundException, TimeRangeException {
int level = currentLevel;
Pair<Long, Long> range = timeRange;
ITmfStateInterval currentLevelInterval = null, nextLevelInterval = null;
} else {
level++;
}
- queryMipmapAttributeRange(level, levelMax, baseQuark, mipmapQuark, range, intervals);
+ queryMipmapAttributeRange(ss, level, levelMax, baseQuark, mipmapQuark, range, intervals);
return;
}
}
}
- queryMipmapAttributeRange(level, levelMax, baseQuark, mipmapQuark, range, intervals);
+ queryMipmapAttributeRange(ss, level, levelMax, baseQuark,
+ mipmapQuark, range, intervals);
- } catch (AttributeNotFoundException e) {
- e.printStackTrace();
- } catch (TimeRangeException e) {
- e.printStackTrace();
} catch (StateSystemDisposedException e) {
- /* Ignored */
+ /* We are shutting down, ignore the operation */
}
}
- private static Pair<Long, Long> updateTimeRange(Pair<Long, Long> timeRange, ITmfStateInterval currentLevelInterval) {
+ private static Pair<Long, Long> updateTimeRange(Pair<Long, Long> timeRange,
+ ITmfStateInterval currentLevelInterval) {
if (currentLevelInterval.getEndTime() >= timeRange.getSecond()) {
return null;
}
- long startTime = Math.max(timeRange.getFirst(), Math.min(currentLevelInterval.getEndTime() + 1, timeRange.getSecond()));
+ long startTime = Math.max(timeRange.getFirst(),
+ Math.min(currentLevelInterval.getEndTime() + 1, timeRange.getSecond()));
return new Pair<Long, Long>(startTime, timeRange.getSecond());
}
- private static boolean isFullyOverlapped(Pair<Long, Long> range, ITmfStateInterval interval) {
- if (range.getFirst() >= range.getSecond() || interval.getStartTime() >= interval.getEndTime()) {
+ private static boolean isFullyOverlapped(Pair<Long, Long> range,
+ ITmfStateInterval interval) {
+ if (range.getFirst() >= range.getSecond() ||
+ interval.getStartTime() >= interval.getEndTime()) {
return false;
}
- if (range.getFirst() <= interval.getStartTime() && range.getSecond() >= interval.getEndTime()) {
+ if (range.getFirst() <= interval.getStartTime() &&
+ range.getSecond() >= interval.getEndTime()) {
return true;
}
return false;
}
-
}
projects / deliverable / tracecompass.git / commitdiff
