blob: bcd2f4425bc8d1a5b629cfcda34dac8f41d9bf01 [file] [log] [blame]
#include "dbus-sdr/sensorutils.hpp"
#include <cmath>
#include "gtest/gtest.h"
// There is a surprising amount of slop in the math,
// thanks to all the rounding and conversion.
// The "x" byte value can drift by up to 2 away, I have seen.
static constexpr int8_t expectedSlopX = 2;
// Unlike expectedSlopX, this is a ratio, not an integer
// It scales based on the range of "y"
static constexpr double expectedSlopY = 0.01;
// The algorithm here was copied from ipmitool
// sdr_convert_sensor_reading() function
// https://github.com/ipmitool/ipmitool/blob/42a023ff0726c80e8cc7d30315b987fe568a981d/lib/ipmi_sdr.c#L360
double ipmitool_y_from_x(uint8_t x, int m, int k2_rExp, int b, int k1_bExp,
bool bSigned)
{
double result;
// Rename to exactly match names and types (except analog) from ipmitool
uint8_t val = x;
double k1 = k1_bExp;
double k2 = k2_rExp;
int analog = bSigned ? 2 : 0;
// Begin paste here
// Only change is to comment out complicated structure in switch statement
switch (/*sensor->cmn.unit.*/ analog)
{
case 0:
result = (double)(((m * val) + (b * pow(10, k1))) * pow(10, k2));
break;
case 1:
if (val & 0x80)
val++;
/* Deliberately fall through to case 2. */
[[fallthrough]];
case 2:
result =
(double)(((m * (int8_t)val) + (b * pow(10, k1))) * pow(10, k2));
break;
default:
/* Oops! This isn't an analog sensor. */
return 0.0;
}
// End paste here
// Ignoring linearization curves and postprocessing that follows,
// assuming all sensors are perfectly linear
return result;
}
void testValue(int x, double y, int16_t M, int8_t rExp, int16_t B, int8_t bExp,
bool bSigned, double yRange)
{
double yRoundtrip;
int result;
// There is intentionally no exception catching here,
// because if getSensorAttributes() returned true,
// it is a promise that all of these should work.
if (bSigned)
{
int8_t expect = x;
int8_t actual =
ipmi::scaleIPMIValueFromDouble(y, M, rExp, B, bExp, bSigned);
result = actual;
yRoundtrip = ipmitool_y_from_x(actual, M, rExp, B, bExp, bSigned);
EXPECT_NEAR(actual, expect, expectedSlopX);
}
else
{
uint8_t expect = x;
uint8_t actual =
ipmi::scaleIPMIValueFromDouble(y, M, rExp, B, bExp, bSigned);
result = actual;
yRoundtrip = ipmitool_y_from_x(actual, M, rExp, B, bExp, bSigned);
EXPECT_NEAR(actual, expect, expectedSlopX);
}
// Scale the amount of allowed slop in y based on range, so ratio similar
double yTolerance = yRange * expectedSlopY;
// double yError = std::abs(y - yRoundtrip);
EXPECT_NEAR(y, yRoundtrip, yTolerance);
char szFormat[1024];
sprintf(szFormat,
"Value | xExpect %4d | xResult %4d "
"| M %5d | rExp %3d "
"| B %5d | bExp %3d | bSigned %1d | y %18.3f | yRoundtrip %18.3f\n",
x, result, M, (int)rExp, B, (int)bExp, (int)bSigned, y, yRoundtrip);
std::cout << szFormat;
}
void testBounds(double yMin, double yMax, bool bExpectedOutcome = true)
{
int16_t mValue;
int8_t rExp;
int16_t bValue;
int8_t bExp;
bool bSigned;
bool result;
result = ipmi::getSensorAttributes(yMax, yMin, mValue, rExp, bValue, bExp,
bSigned);
EXPECT_EQ(result, bExpectedOutcome);
if (!result)
{
return;
}
char szFormat[1024];
sprintf(szFormat,
"Bounds | yMin %18.3f | yMax %18.3f | M %5d"
" | rExp %3d | B %5d | bExp %3d | bSigned %1d\n",
yMin, yMax, mValue, (int)rExp, bValue, (int)bExp, (int)bSigned);
std::cout << szFormat;
double y50p = (yMin + yMax) / 2.0;
// Average the average
double y25p = (yMin + y50p) / 2.0;
double y75p = (y50p + yMax) / 2.0;
// This range value is only used for tolerance checking, not computation
double yRange = yMax - yMin;
if (bSigned)
{
int8_t xMin = -128;
int8_t x25p = -64;
int8_t x50p = 0;
int8_t x75p = 64;
int8_t xMax = 127;
testValue(xMin, yMin, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(x25p, y25p, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(x50p, y50p, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(x75p, y75p, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(xMax, yMax, mValue, rExp, bValue, bExp, bSigned, yRange);
}
else
{
uint8_t xMin = 0;
uint8_t x25p = 64;
uint8_t x50p = 128;
uint8_t x75p = 192;
uint8_t xMax = 255;
testValue(xMin, yMin, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(x25p, y25p, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(x50p, y50p, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(x75p, y75p, mValue, rExp, bValue, bExp, bSigned, yRange);
testValue(xMax, yMax, mValue, rExp, bValue, bExp, bSigned, yRange);
}
}
void testRanges(void)
{
// The ranges from the main TEST function
testBounds(0x0, 0xFF);
testBounds(-128, 127);
testBounds(0, 16000);
testBounds(0, 20);
testBounds(8000, 16000);
testBounds(-10, 10);
testBounds(0, 277);
testBounds(0, 0, false);
testBounds(10, 12);
// Additional test cases recommended to me by hardware people
testBounds(-40, 150);
testBounds(0, 1);
testBounds(0, 2);
testBounds(0, 4);
testBounds(0, 8);
testBounds(35, 65);
testBounds(0, 18);
testBounds(0, 25);
testBounds(0, 80);
testBounds(0, 500);
// Additional sanity checks
testBounds(0, 255);
testBounds(-255, 0);
testBounds(-255, 255);
testBounds(0, 1000);
testBounds(-1000, 0);
testBounds(-1000, 1000);
testBounds(0, 255000);
testBounds(-128000000, 127000000);
testBounds(-50000, 0);
testBounds(-40000, 10000);
testBounds(-30000, 20000);
testBounds(-20000, 30000);
testBounds(-10000, 40000);
testBounds(0, 50000);
testBounds(-1e3, 1e6);
testBounds(-1e6, 1e3);
// Extreme ranges are now possible
testBounds(0, 1e10);
testBounds(0, 1e11);
testBounds(0, 1e12);
testBounds(0, 1e13, false);
testBounds(-1e10, 0);
testBounds(-1e11, 0);
testBounds(-1e12, 0);
testBounds(-1e13, 0, false);
testBounds(-1e9, 1e9);
testBounds(-1e10, 1e10);
testBounds(-1e11, 1e11);
testBounds(-1e12, 1e12, false);
// Large multiplier but small offset
testBounds(1e4, 1e4 + 255);
testBounds(1e5, 1e5 + 255);
testBounds(1e6, 1e6 + 255);
testBounds(1e7, 1e7 + 255);
testBounds(1e8, 1e8 + 255);
testBounds(1e9, 1e9 + 255);
testBounds(1e10, 1e10 + 255, false);
// Input validation against garbage
testBounds(0, INFINITY, false);
testBounds(-INFINITY, 0, false);
testBounds(-INFINITY, INFINITY, false);
testBounds(0, NAN, false);
testBounds(NAN, 0, false);
testBounds(NAN, NAN, false);
// Noteworthy binary integers
testBounds(0, std::pow(2.0, 32.0) - 1.0);
testBounds(0, std::pow(2.0, 32.0));
testBounds(0.0 - std::pow(2.0, 31.0), std::pow(2.0, 31.0));
testBounds((0.0 - std::pow(2.0, 31.0)) - 1.0, std::pow(2.0, 31.0));
// Similar but negative (note additional commented-out below)
testBounds(-1e1, (-1e1) + 255);
testBounds(-1e2, (-1e2) + 255);
// Ranges of negative numbers (note additional commented-out below)
testBounds(-10400, -10000);
testBounds(-15000, -14000);
testBounds(-10000, -9000);
testBounds(-1000, -900);
testBounds(-1000, -800);
testBounds(-1000, -700);
testBounds(-1000, -740);
// Very small ranges (note additional commented-out below)
testBounds(0, 0.1);
testBounds(0, 0.01);
testBounds(0, 0.001);
testBounds(0, 0.0001);
testBounds(0, 0.000001, false);
#if 0
// TODO(): The algorithm in this module is better than it was before,
// but the resulting value of X is still wrong under certain conditions,
// such as when the range between min and max is around 255,
// and the offset is fairly extreme compared to the multiplier.
// Not sure why this is, but these ranges are contrived,
// and real-world examples would most likely never be this way.
testBounds(-10290, -10000);
testBounds(-10280, -10000);
testBounds(-10275,-10000);
testBounds(-10270,-10000);
testBounds(-10265,-10000);
testBounds(-10260,-10000);
testBounds(-10255,-10000);
testBounds(-10250,-10000);
testBounds(-10245,-10000);
testBounds(-10256,-10000);
testBounds(-10512, -10000);
testBounds(-11024, -10000);
// TODO(): This also fails, due to extreme small range, loss of precision
testBounds(0, 0.00001);
// TODO(): Interestingly, if bSigned is forced false,
// causing "x" to have range of (0,255) instead of (-128,127),
// these test cases change from failing to passing!
// Not sure why this is, perhaps a mathematician might know.
testBounds(-10300, -10000);
testBounds(-1000,-750);
testBounds(-1e3, (-1e3) + 255);
testBounds(-1e4, (-1e4) + 255);
testBounds(-1e5, (-1e5) + 255);
testBounds(-1e6, (-1e6) + 255);
#endif
}
TEST(sensorutils, TranslateToIPMI)
{
/*bool getSensorAttributes(double maxValue, double minValue, int16_t
&mValue, int8_t &rExp, int16_t &bValue, int8_t &bExp, bool &bSigned); */
// normal unsigned sensor
double maxValue = 0xFF;
double minValue = 0x0;
int16_t mValue;
int8_t rExp;
int16_t bValue;
int8_t bExp;
bool bSigned;
bool result;
uint8_t scaledVal;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, false);
EXPECT_EQ(mValue, 1);
EXPECT_EQ(rExp, 0);
EXPECT_EQ(bValue, 0);
EXPECT_EQ(bExp, 0);
}
double expected = 0x50;
scaledVal = ipmi::scaleIPMIValueFromDouble(0x50, mValue, rExp, bValue, bExp,
bSigned);
EXPECT_NEAR(scaledVal, expected, expected * 0.01);
// normal signed sensor
maxValue = 127;
minValue = -128;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, true);
EXPECT_EQ(mValue, 1);
EXPECT_EQ(rExp, 0);
EXPECT_EQ(bValue, 0);
EXPECT_EQ(bExp, 0);
}
// check negative values
expected = 236; // 2s compliment -20
scaledVal = ipmi::scaleIPMIValueFromDouble(-20, mValue, rExp, bValue, bExp,
bSigned);
EXPECT_NEAR(scaledVal, expected, expected * 0.01);
// fan example
maxValue = 16000;
minValue = 0;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, false);
EXPECT_EQ(mValue, floor((16000.0 / 0xFF) + 0.5));
EXPECT_EQ(rExp, 0);
EXPECT_EQ(bValue, 0);
EXPECT_EQ(bExp, 0);
}
// voltage sensor example
maxValue = 20;
minValue = 0;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, false);
EXPECT_EQ(mValue, floor(((20.0 / 0xFF) / std::pow(10, rExp)) + 0.5));
EXPECT_EQ(rExp, -3);
EXPECT_EQ(bValue, 0);
EXPECT_EQ(bExp, 0);
}
scaledVal = ipmi::scaleIPMIValueFromDouble(12.2, mValue, rExp, bValue, bExp,
bSigned);
expected = 12.2 / (mValue * std::pow(10, rExp));
EXPECT_NEAR(scaledVal, expected, expected * 0.01);
// shifted fan example
maxValue = 16000;
minValue = 8000;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, false);
EXPECT_EQ(mValue, floor(((8000.0 / 0xFF) / std::pow(10, rExp)) + 0.5));
EXPECT_EQ(rExp, -1);
EXPECT_EQ(bValue, 8);
EXPECT_EQ(bExp, 4);
}
// signed voltage sensor example
maxValue = 10;
minValue = -10;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, true);
EXPECT_EQ(mValue, floor(((20.0 / 0xFF) / std::pow(10, rExp)) + 0.5));
EXPECT_EQ(rExp, -3);
// Although this seems like a weird magic number,
// it is because the range (-128,127) is not symmetrical about zero,
// unlike the range (-10,10), so this introduces some distortion.
EXPECT_EQ(bValue, 392);
EXPECT_EQ(bExp, -1);
}
scaledVal =
ipmi::scaleIPMIValueFromDouble(5, mValue, rExp, bValue, bExp, bSigned);
expected = 5 / (mValue * std::pow(10, rExp));
EXPECT_NEAR(scaledVal, expected, expected * 0.01);
// reading = max example
maxValue = 277;
minValue = 0;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, false);
}
scaledVal = ipmi::scaleIPMIValueFromDouble(maxValue, mValue, rExp, bValue,
bExp, bSigned);
expected = 0xFF;
EXPECT_NEAR(scaledVal, expected, expected * 0.01);
// 0, 0 failure
maxValue = 0;
minValue = 0;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, false);
// too close *success* (was previously failure!)
maxValue = 12;
minValue = 10;
result = ipmi::getSensorAttributes(maxValue, minValue, mValue, rExp, bValue,
bExp, bSigned);
EXPECT_EQ(result, true);
if (result)
{
EXPECT_EQ(bSigned, false);
EXPECT_EQ(mValue, floor(((2.0 / 0xFF) / std::pow(10, rExp)) + 0.5));
EXPECT_EQ(rExp, -4);
EXPECT_EQ(bValue, 1);
EXPECT_EQ(bExp, 5);
}
}
TEST(sensorUtils, TestRanges)
{
// Additional test ranges, each running through a series of values,
// to make sure the values of "x" and "y" go together and make sense,
// for the resulting scaling attributes from each range.
// Unlike the TranslateToIPMI test, exact matches of the
// getSensorAttributes() results (the coefficients) are not required,
// because they are tested through actual use, relating "x" to "y".
testRanges();
}