From 642c8ccca33cff44d8059b2a3768db399be6fdc6 Mon Sep 17 00:00:00 2001 From: swateeshrivastava Date: Fri, 15 Feb 2019 12:46:31 +0530 Subject: [PATCH] UT for adt7481 --- firmware/ec/inc/devices/adt7481.h | 12 + firmware/ec/src/devices/adt7481.c | 12 +- firmware/ec/test/Makefile | 3 + firmware/ec/test/fake/fake_adt7481.c | 66 ++ firmware/ec/test/include/test_adt7481.h | 100 +++ firmware/ec/test/suites/Test_adt7481.c | 1001 +++++++++++++++++++++++ 6 files changed, 1188 insertions(+), 6 deletions(-) create mode 100644 firmware/ec/test/fake/fake_adt7481.c create mode 100644 firmware/ec/test/include/test_adt7481.h create mode 100644 firmware/ec/test/suites/Test_adt7481.c diff --git a/firmware/ec/inc/devices/adt7481.h b/firmware/ec/inc/devices/adt7481.h index 8d6f52fbb9..d000ed699f 100644 --- a/firmware/ec/inc/devices/adt7481.h +++ b/firmware/ec/inc/devices/adt7481.h @@ -167,5 +167,17 @@ ReturnStatus adt7481_get_therm_hysteresis(const I2C_Dev *i2c_dev, int8_t *tempHysteresisValue); ReturnStatus adt7481_set_therm_hysteresis(const I2C_Dev *i2c_dev, int8_t tempHysteresisValue); +ReturnStatus adt7481_set_remote1_temp_therm_limit(const I2C_Dev *i2c_dev, + int8_t tempLimitValue); +ReturnStatus adt7481_set_remote1_temp_high_limit(const I2C_Dev *i2c_dev, + int8_t tempLimitValue); +ReturnStatus adt7481_set_remote1_temp_low_limit(const I2C_Dev *i2c_dev, + int8_t tempLimitValue); +ReturnStatus adt7481_get_remote1_temp_therm_limit(const I2C_Dev *i2c_dev, + int8_t *tempLimitValue); +ReturnStatus adt7481_get_remote1_temp_high_limit(const I2C_Dev *i2c_dev, + int8_t *tempLimitValue); +ReturnStatus adt7481_get_remote1_temp_low_limit(const I2C_Dev *i2c_dev, + int8_t *tempLimitValue); #endif /* ADT7481_H_ */ diff --git a/firmware/ec/src/devices/adt7481.c b/firmware/ec/src/devices/adt7481.c index 7b3b89ce3e..7717cda03a 100644 --- a/firmware/ec/src/devices/adt7481.c +++ b/firmware/ec/src/devices/adt7481.c @@ -245,11 +245,11 @@ ePostCode adt7481_probe(const I2C_Dev *i2c_dev, POSTData *postData) } else if ((devId == TEMP_ADT7481_DEV_ID) && (manfId == TEMP_ADT7481_MANF_ID)) { postcode = POST_DEV_FOUND; + post_update_POSTData(postData, i2c_dev->bus, i2c_dev->slave_addr, + manfId, devId); } else { postcode = POST_DEV_ID_MISMATCH; } - post_update_POSTData(postData, i2c_dev->bus, i2c_dev->slave_addr, manfId, - devId); return postcode; } @@ -1122,7 +1122,7 @@ ReturnStatus adt7481_set_remote1_temp_offset(const I2C_Dev *i2c_dev, int16_t tempOffsetValue) { ReturnStatus status = RETURN_NOTOK; - uint8_t regValue = 0x0000; + uint16_t regValue = 0x0000; /* Converting Temp limit into the register value */ regValue = TEMP_TO_REG_U16(tempOffsetValue); @@ -1132,7 +1132,7 @@ ReturnStatus adt7481_set_remote1_temp_offset(const I2C_Dev *i2c_dev, (uint8_t)regValue); if (status == RETURN_OK) { /* Write MSB data */ - status = adt7481_raw_write(i2c_dev, ADT7481_REG_W_REMOTE1_OFFSET_L, + status = adt7481_raw_write(i2c_dev, ADT7481_REG_W_REMOTE1_OFFSET_H, (uint8_t)(regValue >> 8)); } return status; @@ -1162,7 +1162,7 @@ ReturnStatus adt7481_get_remote2_temp_offset(const I2C_Dev *i2c_dev, tempOffsetValue = NULL; } else { /* Read MSB data */ - status = adt7481_raw_read(i2c_dev, ADT7481_REG_R_REMOTE2_OFFSET_L, + status = adt7481_raw_read(i2c_dev, ADT7481_REG_R_REMOTE2_OFFSET_H, &hRegValue); if (status != RETURN_OK) { tempOffsetValue = NULL; @@ -1188,7 +1188,7 @@ ReturnStatus adt7481_set_remote2_temp_offset(const I2C_Dev *i2c_dev, int8_t tempOffsetValue) { ReturnStatus status = RETURN_NOTOK; - uint8_t regValue = 0x0000; + uint16_t regValue = 0x0000; /* Converting Temp limit into the register value */ regValue = TEMP_TO_REG_U16(tempOffsetValue); diff --git a/firmware/ec/test/Makefile b/firmware/ec/test/Makefile index 93ab732630..f4ca145565 100644 --- a/firmware/ec/test/Makefile +++ b/firmware/ec/test/Makefile @@ -203,6 +203,9 @@ $(PATHB)Test_led$(TARGET_EXTENSION): $(STD_FILES) $(TEST_LED_SRC) TEST_OCMP_LED_SRC=$(OCWARE_ROOT)/src/devices/ocmp_wrappers/ocmp_led.c $(OCWARE_ROOT)/src/devices/led.c $(OCWARE_ROOT)/src/devices/sx1509.c $(OCWARE_ROOT)/src/devices/i2cbus.c fake/fake_GPIO.c fake/fake_I2C.c fake/fake_ThreadedISR.c fake/fake_SX1509_register.c fake/fake_led.c stub/stub_GateMutex.c $(OCWARE_ROOT)/platform/oc-sdr/cfg/OC_CONNECT_LED.c $(PATHB)Test_ocmp_led$(TARGET_EXTENSION): $(STD_FILES) $(TEST_OCMP_LED_SRC) +TEST_ADT7481_SRC=$(OCWARE_ROOT)/src/devices/adt7481.c $(OCWARE_ROOT)/src/devices/i2cbus.c fake/fake_GPIO.c fake/fake_I2C.c fake/fake_ThreadedISR.c fake/fake_adt7481.c stub/stub_GateMutex.c $(OCWARE_ROOT)/src/post/post_util.c $(OCWARE_ROOT)/platform/oc-sdr/cfg/OC_CONNECT_SDR.c +$(PATHB)Test_adt7481$(TARGET_EXTENSION): $(STD_FILES) $(TEST_ADT7481_SRC) + $(PATHB)%$(TARGET_EXTENSION): $(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $^ -o $@ $(COV_CMDS) diff --git a/firmware/ec/test/fake/fake_adt7481.c b/firmware/ec/test/fake/fake_adt7481.c new file mode 100644 index 0000000000..c08c7fb23b --- /dev/null +++ b/firmware/ec/test/fake/fake_adt7481.c @@ -0,0 +1,66 @@ +/** + * Copyright (c) 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +#include "include/test_adt7481.h" + +OcGpio_Port s_fake_io_port = { + .fn_table = &FakeGpio_fnTable, + .object_data = &(FakeGpio_Obj){}, +}; + +const I2C_Dev adt_invalid_dev = { + .bus = 7, + .slave_addr = 0x52, +}; + +const I2C_Dev adt_invalid_bus = { + .bus = 3, + .slave_addr = 0x2F, +}; + +uint8_t ADT7481_regs[] = { + [ADT7481_REG_LOCAL_TEMP_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_HIGH_BYTE_R] = 0x00, + [ADT7481_REG_STATUS_1_R] = 0x00, + [ADT7481_REG_CONFIGURATION_1_R] = 0x00, + [ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_R] = 0x00, + [ADT7481_REG_LOCAL_TEMP_HIGH_LIMIT_R] = 0x00, + [ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R] = 0x00, + [ADT7481_REG_CONFIGURATION_1_W] = 0x00, + [ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_W] = 0x00, + [ADT7481_REG_LOCAL_TEMP_HIGH_LIMIT_W] = 0x00, + [ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_W] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_W] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_W] = 0x00, + [ADT7481_REG_ONE_SHOT_W] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_OFFSET_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_1_THERM_LIMIT_R] = 0x00, + [ADT7481_REG_LOCAL_THERM_LIMIT_R] = 0x00, + [ADT7481_REG_THERM_HYSTERESIS_R] = 0x00, + [ADT7481_REG_CONSECUTIVE_ALERT_R] = 0x00, + [ADT7481_REG_STATUS_2_R] = 0x00, + [ADT7481_REG_CONFIGURATION_2_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_HIGH_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_OFFSET_HIGH_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_OFFSET_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_LOW_BYTE_R] = 0x00, + [ADT7481_REG_REMOTE_2_THERM_LIMIT_R] = 0x00, + [ADT7481_REG_DEVICE_ID_R] = 0x00, + [ADT7481_REG_MAN_ID_R] = 0x00, + [ADT7481_REG_END] = 0x00, +}; diff --git a/firmware/ec/test/include/test_adt7481.h b/firmware/ec/test/include/test_adt7481.h new file mode 100644 index 0000000000..e2b4c41235 --- /dev/null +++ b/firmware/ec/test/include/test_adt7481.h @@ -0,0 +1,100 @@ +/** + * Copyright (c) 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +#ifndef _TEST_ADT7481_H +#define _TEST_ADT7481_H + +#include "fake/fake_GPIO.h" +#include "fake/fake_I2C.h" +#include "fake/fake_ThreadedISR.h" +#include "inc/devices/adt7481.h" +#include +#include +#include "unity.h" + +#define ADT7481_CONFIG1_SET_VALUE 0x59 +#define ADT7481_CONFIG1_VALUE 0x58 +#define ADT7481_COVERSION_RATE_CHANNEL_SEL 0x61 +#define ADT7481_DEFAULT_VAL 0xFF +#define ADT7481_INVALID_DEV_ID 0x80 +#define ADT7481_INVALID_MANF_ID 0x40 +#define ADT7481_LOCAL_TEMP_R_VAL 0x63 +#define ADT7481_REMOTE_1_TEMP_HIGH_BYTE_R_VAL 0x54 +#define ADT7481_REMOTE_1_TEMP_LOW_BYTE_R_VAL 0x65 +#define ADT7481_REMOTE_2_TEMP_HIGH_BYTE_R_VAL 0x73 +#define ADT7481_REMOTE_2_TEMP_LOW_BYTE_R_VAL 0x67 +#define ADT7481_SET_COVERSION_RATE_CHANNEL_SEL 0x62 +#define ADT7481_SET_LOCAL_TEMP_LIMIT1 -63 +#define ADT7481_SET_LOCAL_TEMP_LIMIT2 -62 +#define ADT7481_SET_LOCAL_TEMP_LIMIT3 -61 +#define ADT7481_SET_LOCAL_TEMP_LIMIT4 -60 +#define ADT7481_STATUS_1_R_VAL 0x63 +#define ADT7481_STATUS_2_R_VAL 0x64 +#define ADT7481_TEMP_LIMIT1 0x41 +#define ADT7481_TEMP_LIMIT2 0x42 +#define ADT7481_TEMP_LIMIT3 0x43 +#define ADT7481_TEMP_LIMIT4 0x44 +#define ADT7481_REMOTE_TEMP_LIMIT 0x62 +#define ADT7481_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R_VAl 0x1A +#define ADT7481_REMOTE_1_TEMP_HIGH_LIMIT_R_VAL 0x50 +#define ADT7481_REMOTE_1_THER_LIMIT_R_VAL 0x85 +#define ADT7481_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R_VAL 0x67 +#define ADT7481_REMOTE_1_TEMP_LOW_LIMIT_R_VAL 0x89 +#define ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R 0x70 +#define ADT7481_REMOTE_1_TEMP_OFFSET_LOW_BYTE_R 0x67 +#define ADT7481_REMOTE_2_TEMP_LIMIT 0x90 +#define CONF_TEMP_ADT7481_INVALID_PARAM 4 +#define POST_DATA_NULL 0x00 +#define REG_U8_TO_TEMP(y) (y - 64) +#define REG_U16_TO_TEMP(y) (y - 64) +#define TEMP_TO_REG_U8(x) (x + 64) +#define TEMP_TO_REG_U16(x) ((x + 64) << 8) + +typedef enum ADT7481Regs { + ADT7481_REG_LOCAL_TEMP_R = 0x00, + ADT7481_REG_REMOTE_1_TEMP_HIGH_BYTE_R, + ADT7481_REG_STATUS_1_R, + ADT7481_REG_CONFIGURATION_1_R, + ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_R, + ADT7481_REG_LOCAL_TEMP_HIGH_LIMIT_R, + ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_R, + ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_R, + ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R, + ADT7481_REG_CONFIGURATION_1_W, + ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_W, + ADT7481_REG_LOCAL_TEMP_HIGH_LIMIT_W, + ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_W, + ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_W, + ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_W, + ADT7481_REG_ONE_SHOT_W, + ADT7481_REG_REMOTE_1_TEMP_LOW_BYTE_R, + ADT7481_REG_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R, + ADT7481_REG_REMOTE_1_TEMP_OFFSET_LOW_BYTE_R, + ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R, + ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R, + ADT7481_REG_REMOTE_1_THERM_LIMIT_R = 0x19, + ADT7481_REG_LOCAL_THERM_LIMIT_R = 0x20, + ADT7481_REG_THERM_HYSTERESIS_R, + ADT7481_REG_CONSECUTIVE_ALERT_R, + ADT7481_REG_STATUS_2_R, + ADT7481_REG_CONFIGURATION_2_R, + ADT7481_REG_REMOTE_2_TEMP_HIGH_BYTE_R = 0x30, + ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R, + ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R, + ADT7481_REG_REMOTE_2_TEMP_LOW_BYTE_R, + ADT7481_REG_REMOTE_2_TEMP_OFFSET_HIGH_BYTE_R, + ADT7481_REG_REMOTE_2_TEMP_OFFSET_LOW_BYTE_R, + ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_LOW_BYTE_R, + ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_LOW_BYTE_R, + ADT7481_REG_REMOTE_2_THERM_LIMIT_R = 0x39, + ADT7481_REG_DEVICE_ID_R = 0x3D, + ADT7481_REG_MAN_ID_R, + ADT7481_REG_END = 0xFF, +} ADT7481Regs; + +#endif diff --git a/firmware/ec/test/suites/Test_adt7481.c b/firmware/ec/test/suites/Test_adt7481.c new file mode 100644 index 0000000000..c8aaa832bf --- /dev/null +++ b/firmware/ec/test/suites/Test_adt7481.c @@ -0,0 +1,1001 @@ +/** + * Copyright (c) 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ +#include "include/test_adt7481.h" +/* ======================== Constants & variables =========================== */ +extern const I2C_Dev adt_invalid_bus; +extern const I2C_Dev adt_invalid_dev; +extern I2C_Dev sdr_fpga_ts; +extern uint8_t ADT7481_regs[ADT7481_REG_END]; +/* ============================= Boilerplate ================================ */ +void suite_setUp(void) +{ + fake_I2C_init(); + fake_I2C_registerDevSimple(sdr_fpga_ts.bus, sdr_fpga_ts.slave_addr, + ADT7481_regs, sizeof(ADT7481_regs) + 1, + sizeof(ADT7481_regs[0]), sizeof(uint8_t), + FAKE_I2C_DEV_BIG_ENDIAN); + // FakeGpio_registerDevSimple(ADT7481_GpioPins, ADT7481_GpioConfig); +} + +void setUp(void) +{ + memset(ADT7481_regs, 0, sizeof(ADT7481_regs)); +} + +void tearDown(void) +{ +} + +void suite_tearDown(void) +{ + fake_I2C_deinit(); /* This will automatically unregister devices */ +} +/* ================================ Tests =================================== */ + +void test_adt7481_probe(void) +{ + POSTData postData; + + /* Correct Dev id */ + ADT7481_regs[ADT7481_REG_DEVICE_ID_R] = TEMP_ADT7481_DEV_ID; + ADT7481_regs[ADT7481_REG_MAN_ID_R] = TEMP_ADT7481_MANF_ID; + TEST_ASSERT_EQUAL(POST_DEV_FOUND, adt7481_probe(&sdr_fpga_ts, &postData)); + TEST_ASSERT_EQUAL(sdr_fpga_ts.bus, postData.i2cBus); + TEST_ASSERT_EQUAL_HEX8(sdr_fpga_ts.slave_addr, postData.devAddr); + TEST_ASSERT_EQUAL_HEX8(TEMP_ADT7481_DEV_ID, postData.devId); + TEST_ASSERT_EQUAL_HEX8(TEMP_ADT7481_MANF_ID, postData.manId); + + postData.i2cBus = POST_DATA_NULL; + postData.devAddr = POST_DATA_NULL; + postData.manId = POST_DATA_NULL; + postData.devId = POST_DATA_NULL; + /* Missing device */ + TEST_ASSERT_EQUAL(POST_DEV_MISSING, + adt7481_probe(&adt_invalid_dev, &postData)); + TEST_ASSERT_EQUAL(POST_DATA_NULL, postData.i2cBus); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.devAddr); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.manId); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.devId); + + /* Incorrect Dev id */ + ADT7481_regs[ADT7481_REG_DEVICE_ID_R] = ADT7481_INVALID_DEV_ID; + ADT7481_regs[ADT7481_REG_MAN_ID_R] = TEMP_ADT7481_MANF_ID; + TEST_ASSERT_EQUAL(POST_DEV_ID_MISMATCH, + adt7481_probe(&sdr_fpga_ts, &postData)); + TEST_ASSERT_EQUAL(POST_DATA_NULL, postData.i2cBus); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.devAddr); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.manId); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.devId); + + /* Incorrect Manf id */ + ADT7481_regs[ADT7481_REG_DEVICE_ID_R] = TEMP_ADT7481_DEV_ID; + ADT7481_regs[ADT7481_REG_MAN_ID_R] = ADT7481_INVALID_MANF_ID; + TEST_ASSERT_EQUAL(POST_DEV_ID_MISMATCH, + adt7481_probe(&sdr_fpga_ts, &postData)); + TEST_ASSERT_EQUAL(POST_DATA_NULL, postData.i2cBus); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.devAddr); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.manId); + TEST_ASSERT_EQUAL_HEX8(POST_DATA_NULL, postData.devId); +} + +void test_adt7481_get_dev_id(void) +{ + uint8_t devId = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_DEVICE_ID_R] = TEMP_ADT7481_DEV_ID; + + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_dev_id(&sdr_fpga_ts, &devId)); + TEST_ASSERT_EQUAL_HEX8(TEMP_ADT7481_DEV_ID, devId); + + /* Incorrect Dev id */ + ADT7481_regs[ADT7481_REG_DEVICE_ID_R] = ADT7481_INVALID_DEV_ID; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_dev_id(&sdr_fpga_ts, &devId)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_INVALID_DEV_ID, devId); +} + +void test_adt7481_get_mfg_id(void) +{ + uint8_t mfgId = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_MAN_ID_R] = TEMP_ADT7481_MANF_ID; + + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_mfg_id(&sdr_fpga_ts, &mfgId)); + TEST_ASSERT_EQUAL_HEX8(TEMP_ADT7481_MANF_ID, mfgId); + + /* Incorrect Manf id */ + ADT7481_regs[ADT7481_REG_MAN_ID_R] = ADT7481_INVALID_MANF_ID; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_mfg_id(&sdr_fpga_ts, &mfgId)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_INVALID_MANF_ID, mfgId); +} + +void test_adt7481_get_config1(void) +{ + uint8_t configValue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_CONFIGURATION_1_R] = ADT7481_CONFIG1_VALUE; + + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_config1(&sdr_fpga_ts, &configValue)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_CONFIG1_VALUE, configValue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_config1(&adt_invalid_dev, &configValue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_config1(&adt_invalid_bus, &configValue)); +} + +void test_adt7481_set_config1(void) +{ + uint8_t configValue = ADT7481_DEFAULT_VAL; + /* write register */ + ADT7481_regs[ADT7481_REG_CONFIGURATION_1_W] = ADT7481_DEFAULT_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_set_config1( + &sdr_fpga_ts, ADT7481_CONFIG1_SET_VALUE)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_CONFIG1_SET_VALUE, + ADT7481_regs[ADT7481_REG_CONFIGURATION_1_W]); + + ADT7481_regs[ADT7481_REG_CONFIGURATION_1_R] = + ADT7481_regs[ADT7481_REG_CONFIGURATION_1_W]; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_config1(&sdr_fpga_ts, &configValue)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_CONFIG1_SET_VALUE, configValue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_set_config1(&adt_invalid_dev, ADT7481_CONFIG1_SET_VALUE)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_set_config1(&adt_invalid_bus, ADT7481_CONFIG1_SET_VALUE)); +} + +void test_adt7481_get_convo_rate(void) +{ + uint8_t convRateValue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_R] = + ADT7481_COVERSION_RATE_CHANNEL_SEL; + + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_conv_rate(&sdr_fpga_ts, &convRateValue)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_COVERSION_RATE_CHANNEL_SEL, convRateValue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_conv_rate(&adt_invalid_dev, &convRateValue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_conv_rate(&adt_invalid_bus, &convRateValue)); +} + +void test_adt7481_set_convo_rate(void) +{ + uint8_t convRateValue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_W] = 0x00; + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_set_conv_rate( + &sdr_fpga_ts, ADT7481_SET_COVERSION_RATE_CHANNEL_SEL)); + TEST_ASSERT_EQUAL_HEX8( + ADT7481_SET_COVERSION_RATE_CHANNEL_SEL, + ADT7481_regs[ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_W]); + + ADT7481_regs[ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_R] = + ADT7481_regs[ADT7481_REG_COVERSION_RATE_CHANNEL_SEL_W]; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_conv_rate(&sdr_fpga_ts, &convRateValue)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_SET_COVERSION_RATE_CHANNEL_SEL, + convRateValue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_set_conv_rate(&adt_invalid_dev, + ADT7481_SET_COVERSION_RATE_CHANNEL_SEL)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_set_conv_rate(&adt_invalid_bus, + ADT7481_SET_COVERSION_RATE_CHANNEL_SEL)); +} + +void test_adt7481_status1(void) +{ + uint8_t statusValue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_STATUS_1_R] = ADT7481_STATUS_1_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_status1(&sdr_fpga_ts, &statusValue)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_STATUS_1_R_VAL, statusValue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_status1(&adt_invalid_dev, &statusValue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_status1(&adt_invalid_bus, &statusValue)); +} + +void test_adt7481_status2(void) +{ + uint8_t statusValue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_STATUS_2_R] = ADT7481_STATUS_2_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_status2(&sdr_fpga_ts, &statusValue)); + TEST_ASSERT_EQUAL_HEX8(ADT7481_STATUS_2_R_VAL, statusValue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_status2(&adt_invalid_dev, &statusValue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_status2(&adt_invalid_bus, &statusValue)); +} +void test_adt7481_local_temp_val(void) +{ + int16_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_LOCAL_TEMP_R] = ADT7481_LOCAL_TEMP_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_local_temp_val(&sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8(REG_U8_TO_TEMP(ADT7481_LOCAL_TEMP_R_VAL), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_local_temp_val(&adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_get_local_temp_val(&adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_remote1_temp_val(void) +{ + int16_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_BYTE_R] = + ADT7481_REMOTE_1_TEMP_LOW_BYTE_R_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_BYTE_R] = + ADT7481_REMOTE_1_TEMP_HIGH_BYTE_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_remote1_temp_val(&sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_1_TEMP_HIGH_BYTE_R_VAL), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_val( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_val( + &adt_invalid_dev, &tempvalue)); +} + +void test_adt7481_remote2_temp_val(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_BYTE_R] = + ADT7481_REMOTE_2_TEMP_LOW_BYTE_R_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_BYTE_R] = + ADT7481_REMOTE_2_TEMP_HIGH_BYTE_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_remote2_temp_val(&sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_2_TEMP_HIGH_BYTE_R_VAL), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_val( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_val( + &adt_invalid_bus, &tempvalue)); +} + +static void +test_adt7481_get_temp_x_limit(eTempSensorADT7481ConfigParamsId limitToConfig, + uint8_t reg_addr) +{ + int16_t limit; + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT1; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_local_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U8_TO_TEMP(ADT7481_TEMP_LIMIT1), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT2; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_local_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U8_TO_TEMP(ADT7481_TEMP_LIMIT2), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT3; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_local_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U8_TO_TEMP(ADT7481_TEMP_LIMIT3), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT4; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_local_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U8_TO_TEMP(ADT7481_TEMP_LIMIT4), limit); +} + +void test_adt7481_get_local_temp_limit(void) +{ + test_adt7481_get_temp_x_limit(CONF_TEMP_ADT7481_LOW_LIMIT_REG, + ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_R); + test_adt7481_get_temp_x_limit(CONF_TEMP_ADT7481_HIGH_LIMIT_REG, + ADT7481_REG_LOCAL_TEMP_HIGH_LIMIT_R); + // test_adt7481_get_temp_x_limit(CONF_TEMP_ADT7481_THERM_LIMIT_REG, + // ADT7481_REG_LOCAL_THERM_LIMIT_R); + test_adt7481_get_temp_x_limit(CONF_TEMP_ADT7481_THERM_LIMIT_REG, 0x20); +} + +void test_adt7481_get_invalid_local_temp_limit(void) +{ + int16_t limit; + ADT7481_regs[ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_R] = ADT7481_TEMP_LIMIT1; + /* Invalid param */ + + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_local_temp_limit(&sdr_fpga_ts, + CONF_TEMP_ADT7481_INVALID_PARAM, &limit)); + + /* Invalid dev */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_local_temp_limit( + &adt_invalid_dev, ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_R, &limit)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_local_temp_limit( + &adt_invalid_bus, ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_R, &limit)); +} + +static void +test_adt7481_set_temp_x_limit(eTempSensorADT7481ConfigParamsId limitToConfig, + uint8_t reg_addr) +{ + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_set_local_temp_limit(&sdr_fpga_ts, limitToConfig, + ADT7481_SET_LOCAL_TEMP_LIMIT1)); + TEST_ASSERT_EQUAL(TEMP_TO_REG_U8(ADT7481_SET_LOCAL_TEMP_LIMIT1), + ADT7481_regs[reg_addr]); + + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_set_local_temp_limit(&sdr_fpga_ts, limitToConfig, + ADT7481_SET_LOCAL_TEMP_LIMIT2)); + TEST_ASSERT_EQUAL(TEMP_TO_REG_U8(ADT7481_SET_LOCAL_TEMP_LIMIT2), + ADT7481_regs[reg_addr]); + + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_set_local_temp_limit(&sdr_fpga_ts, limitToConfig, + ADT7481_SET_LOCAL_TEMP_LIMIT3)); + TEST_ASSERT_EQUAL(TEMP_TO_REG_U8(ADT7481_SET_LOCAL_TEMP_LIMIT3), + ADT7481_regs[reg_addr]); + + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_set_local_temp_limit(&sdr_fpga_ts, limitToConfig, + ADT7481_SET_LOCAL_TEMP_LIMIT4)); + TEST_ASSERT_EQUAL(TEMP_TO_REG_U8(ADT7481_SET_LOCAL_TEMP_LIMIT4), + ADT7481_regs[reg_addr]); +} + +void test_adt7481_set_local_temp_limit(void) +{ + test_adt7481_set_temp_x_limit(CONF_TEMP_ADT7481_LOW_LIMIT_REG, + ADT7481_REG_LOCAL_TEMP_LOW_LIMIT_W); + test_adt7481_set_temp_x_limit(CONF_TEMP_ADT7481_HIGH_LIMIT_REG, + ADT7481_REG_LOCAL_TEMP_HIGH_LIMIT_W); + test_adt7481_set_temp_x_limit(CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REG_LOCAL_THERM_LIMIT_R); +} + +void test_adt7481_set_invalid_local_temp_limit(void) +{ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_local_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_INVALID_PARAM, + ADT7481_SET_LOCAL_TEMP_LIMIT4)); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_local_temp_limit( + &adt_invalid_dev, CONF_TEMP_ADT7481_LOW_LIMIT_REG, + ADT7481_SET_LOCAL_TEMP_LIMIT4)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_local_temp_limit( + &adt_invalid_bus, CONF_TEMP_ADT7481_LOW_LIMIT_REG, + ADT7481_SET_LOCAL_TEMP_LIMIT4)); +} + +void test_adt7481_remote1_temp_low_limit(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R] = + ADT7481_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R] = + ADT7481_REMOTE_1_TEMP_LOW_LIMIT_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_low_limit( + &sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_1_TEMP_LOW_LIMIT_R_VAL), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_low_limit( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_low_limit( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_remote1_temp_high_limit(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R] = + ADT7481_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R_VAl; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_R] = + ADT7481_REMOTE_1_TEMP_HIGH_LIMIT_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_high_limit( + &sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_1_TEMP_HIGH_LIMIT_R_VAL), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_high_limit( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_high_limit( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_remote1_temp_therm_limit(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_THERM_LIMIT_R] = + ADT7481_REMOTE_1_THER_LIMIT_R_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_therm_limit( + &sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8(REG_U8_TO_TEMP(ADT7481_REMOTE_1_THER_LIMIT_R_VAL), + tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_therm_limit( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_therm_limit( + &adt_invalid_bus, &tempvalue)); +} + +static void test_adt7481_get_remote1_temp_x_limit( + eTempSensorADT7481ConfigParamsId limitToConfig, uint8_t reg_addr) +{ + int8_t limit = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R] = + ADT7481_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R_VAL; + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT1; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT1), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT2; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT2), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT3; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT3), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT4; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote1_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT4), limit); +} + +void test_adt7481_get_remote1_temp_limit(void) +{ + test_adt7481_get_remote1_temp_x_limit( + CONF_TEMP_ADT7481_LOW_LIMIT_REG, ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R); + test_adt7481_get_remote1_temp_x_limit( + CONF_TEMP_ADT7481_HIGH_LIMIT_REG, + ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_R); + test_adt7481_get_remote1_temp_x_limit(CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REG_REMOTE_1_THERM_LIMIT_R); +} + +void test_adt7481_get_invalid_remote1_temp_limit(void) +{ + int8_t limit = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R] = + ADT7481_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R] = ADT7481_TEMP_LIMIT1; + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_remote1_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_INVALID_PARAM, &limit)); + + /* Invalid dev */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_remote1_temp_limit( + &adt_invalid_dev, ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R, &limit)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_remote1_temp_limit( + &adt_invalid_bus, ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_R, &limit)); +} + +void test_adt7481_set_remote1_temp_low_limit(void) +{ + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_W] = 0x00; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_set_remote1_temp_low_limit( + &sdr_fpga_ts, ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8, + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_W]); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT)), + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_LOW_BYTE_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_low_limit( + &adt_invalid_dev, ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_low_limit( + &adt_invalid_bus, ADT7481_REMOTE_TEMP_LIMIT)); +} + +void test_adt7481_set_remote1_temp_high_limit(void) +{ + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_W] = 0x00; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_set_remote1_temp_high_limit( + &sdr_fpga_ts, ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_W]); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT)), + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_LOW_BYTE_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_high_limit( + &adt_invalid_dev, ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_high_limit( + &adt_invalid_bus, ADT7481_REMOTE_TEMP_LIMIT)); +} + +void test_adt7481_set_remote1_temp_therm_limit(void) +{ + ADT7481_regs[ADT7481_REG_REMOTE_1_THERM_LIMIT_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_set_remote1_temp_therm_limit( + &sdr_fpga_ts, ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8(TEMP_TO_REG_U8(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_1_THERM_LIMIT_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_therm_limit( + &adt_invalid_dev, ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_therm_limit( + &adt_invalid_bus, ADT7481_REMOTE_TEMP_LIMIT)); +} + +void test_adt7481_set_remote1_temp_limit(void) +{ + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote1_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_LOW_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8, + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_LOW_LIMIT_W]); + + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote1_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_HIGH_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_HIGH_LIMIT_W]); + + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote1_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL(TEMP_TO_REG_U8(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_1_THERM_LIMIT_R]); + + /* Invalid param */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_INVALID_PARAM, + ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_limit( + &adt_invalid_dev, CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_limit( + &adt_invalid_bus, CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); +} + +void test_adt7481_set_remote2_temp_low_limit(void) +{ + uint8_t tempvalue = ADT7481_REMOTE_TEMP_LIMIT; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R] = 0x00; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_LOW_BYTE_R] = 0x00; + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_set_remote2_temp_low_limit(&sdr_fpga_ts, tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_LOW_BYTE_R]); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_low_limit( + &adt_invalid_dev, tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_low_limit( + &adt_invalid_bus, tempvalue)); +} + +void test_adt7481_set_remote2_temp_high_limit(void) +{ + uint8_t tempvalue = ADT7481_REMOTE_TEMP_LIMIT; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R] = 0x00; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_LOW_BYTE_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_set_remote2_temp_high_limit( + &sdr_fpga_ts, tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R]); + TEST_ASSERT_EQUAL_HEX8( + TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_LOW_BYTE_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_high_limit( + &adt_invalid_dev, tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_high_limit( + &adt_invalid_bus, tempvalue)); +} + +void test_adt7481_set_remote2_temp_therm_limit(void) +{ + uint8_t tempvalue = ADT7481_REMOTE_TEMP_LIMIT; + ADT7481_regs[ADT7481_REG_REMOTE_2_THERM_LIMIT_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_set_remote2_temp_therm_limit( + &sdr_fpga_ts, tempvalue)); + TEST_ASSERT_EQUAL_HEX8(TEMP_TO_REG_U8(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_2_THERM_LIMIT_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_therm_limit( + &adt_invalid_dev, tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_therm_limit( + &adt_invalid_bus, tempvalue)); +} + +void test_adt7481_set_remote2_temp_limit(void) +{ + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote2_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_LOW_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8( + TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_LOW_BYTE_R]); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R]); + + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote2_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_HIGH_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R]); + TEST_ASSERT_EQUAL_HEX8( + TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_LOW_BYTE_R]); + + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote2_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + TEST_ASSERT_EQUAL_HEX8(TEMP_TO_REG_U8(ADT7481_REMOTE_TEMP_LIMIT), + ADT7481_regs[ADT7481_REG_REMOTE_2_THERM_LIMIT_R]); + + /* Invalid param */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote2_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_INVALID_PARAM, + ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote2_temp_limit( + &adt_invalid_dev, CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, + adt7481_set_remote1_temp_limit( + &adt_invalid_bus, CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REMOTE_TEMP_LIMIT)); +} + +void test_adt7481_set_remote1_temp_offset(void) +{ + uint16_t tempvalue = ADT7481_REMOTE_TEMP_LIMIT; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R] = 0x00; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_OFFSET_LOW_BYTE_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote1_temp_offset(&sdr_fpga_ts, tempvalue)); + TEST_ASSERT_EQUAL( + (uint8_t)(TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote1_temp_offset( + &adt_invalid_dev, tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote1_temp_offset( + &adt_invalid_bus, tempvalue)); +} + +void test_adt7481_set_remote2_temp_offset(void) +{ + uint8_t tempvalue = ADT7481_REMOTE_TEMP_LIMIT; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_OFFSET_HIGH_BYTE_R] = 0x00; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_OFFSET_LOW_BYTE_R] = 0x00; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_remote2_temp_offset(&sdr_fpga_ts, tempvalue)); + TEST_ASSERT_EQUAL( + (TEMP_TO_REG_U16(ADT7481_REMOTE_TEMP_LIMIT) >> 8), + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_OFFSET_HIGH_BYTE_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_offset( + &adt_invalid_dev, tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_remote2_temp_offset( + &adt_invalid_bus, tempvalue)); +} + +void test_adt7481_remote2_temp_low_limit(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R] = + ADT7481_REMOTE_2_TEMP_LIMIT; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_low_limit( + &sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8(REG_U16_TO_TEMP(ADT7481_REMOTE_2_TEMP_LIMIT), + tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_low_limit( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_low_limit( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_remote2_temp_high_limit(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R] = + ADT7481_REMOTE_2_TEMP_LIMIT; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_high_limit( + &sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8(REG_U16_TO_TEMP(ADT7481_REMOTE_2_TEMP_LIMIT), + tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_high_limit( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_high_limit( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_remote2_temp_therm_limit(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_2_THERM_LIMIT_R] = + ADT7481_REMOTE_2_TEMP_LIMIT; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_therm_limit( + &sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8(REG_U16_TO_TEMP(ADT7481_REMOTE_2_TEMP_LIMIT), + tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_therm_limit( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_therm_limit( + &adt_invalid_bus, &tempvalue)); +} + +static void test_adt7481_get_remote2_temp_x_limit( + eTempSensorADT7481ConfigParamsId limitToConfig, uint8_t reg_addr) +{ + int8_t limit; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_LOW_BYTE_R] = 0x67; + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT1; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT1), limit); + + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_LOW_BYTE_R] = 0x67; + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT2; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT2), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT3; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT3), limit); + + ADT7481_regs[reg_addr] = ADT7481_TEMP_LIMIT4; + TEST_ASSERT_EQUAL(RETURN_OK, adt7481_get_remote2_temp_limit( + &sdr_fpga_ts, limitToConfig, &limit)); + TEST_ASSERT_EQUAL(REG_U16_TO_TEMP(ADT7481_TEMP_LIMIT4), limit); +} + +void test_adt7481_get_remote2_temp_limit(void) +{ + test_adt7481_get_remote2_temp_x_limit( + CONF_TEMP_ADT7481_LOW_LIMIT_REG, ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R); + test_adt7481_get_remote2_temp_x_limit( + CONF_TEMP_ADT7481_HIGH_LIMIT_REG, + ADT7481_REG_REMOTE_2_TEMP_HIGH_LIMIT_R); + test_adt7481_get_remote2_temp_x_limit(CONF_TEMP_ADT7481_THERM_LIMIT_REG, + ADT7481_REG_REMOTE_2_THERM_LIMIT_R); +} + +void test_adt7481_get_invalid_remote2_temp_limit(void) +{ + int8_t limit; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_LOW_LIMIT_R] = ADT7481_TEMP_LIMIT1; + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_remote2_temp_limit( + &sdr_fpga_ts, CONF_TEMP_ADT7481_INVALID_PARAM, &limit)); + + /* Invalid dev */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_remote2_temp_limit( + &adt_invalid_dev, CONF_TEMP_ADT7481_LOW_LIMIT_REG, &limit)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL( + RETURN_NOTOK, + adt7481_get_remote2_temp_limit( + &adt_invalid_bus, CONF_TEMP_ADT7481_LOW_LIMIT_REG, &limit)); +} + +void test_adt7481_get_remote1_temp_offset(void) +{ + int16_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_OFFSET_LOW_BYTE_R] = + ADT7481_REMOTE_1_TEMP_OFFSET_LOW_BYTE_R; + ADT7481_regs[ADT7481_REG_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R] = + ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R; + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_get_remote1_temp_offset(&sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_offset( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote1_temp_offset( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_get_remote2_temp_offset(void) +{ + int16_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_REMOTE_2_TEMP_OFFSET_HIGH_BYTE_R] = + ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R; + TEST_ASSERT_EQUAL( + RETURN_OK, adt7481_get_remote2_temp_offset(&sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_offset( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_remote2_temp_offset( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_get_therm_hysteresis(void) +{ + int8_t tempvalue = ADT7481_DEFAULT_VAL; + ADT7481_regs[ADT7481_REG_THERM_HYSTERESIS_R] = + ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_get_therm_hysteresis(&sdr_fpga_ts, &tempvalue)); + TEST_ASSERT_EQUAL_HEX8( + REG_U16_TO_TEMP(ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R), tempvalue); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_therm_hysteresis( + &adt_invalid_dev, &tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_get_therm_hysteresis( + &adt_invalid_bus, &tempvalue)); +} + +void test_adt7481_set_therm_hysteresis(void) +{ + int8_t tempvalue = ADT7481_REMOTE_1_TEMP_OFFSET_HIGH_BYTE_R; + ADT7481_regs[ADT7481_REG_THERM_HYSTERESIS_R] = ADT7481_DEFAULT_VAL; + TEST_ASSERT_EQUAL(RETURN_OK, + adt7481_set_therm_hysteresis(&sdr_fpga_ts, tempvalue)); + TEST_ASSERT_EQUAL_HEX8(TEMP_TO_REG_U8(tempvalue), + ADT7481_regs[ADT7481_REG_THERM_HYSTERESIS_R]); + + /* Invalid dev */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_therm_hysteresis( + &adt_invalid_dev, tempvalue)); + + /* Invalid bus */ + TEST_ASSERT_EQUAL(RETURN_NOTOK, adt7481_set_therm_hysteresis( + &adt_invalid_bus, tempvalue)); +}