diff --git a/module/power_capping/include/mod_power_capping.h b/module/power_capping/include/mod_power_capping.h index 8a893dc1fb4526897e8f042b6131affce729d621..3ce86f28905329dd4138cb18d350655a5a4e76e9 100644 --- a/module/power_capping/include/mod_power_capping.h +++ b/module/power_capping/include/mod_power_capping.h @@ -240,6 +240,12 @@ enum mod_power_capping_notification_idx { /*! Power cap change notification. */ MOD_POWER_CAPPING_NOTIFICATION_IDX_CAP_CHANGE, + /*! PAI changed notification. */ + MOD_POWER_CAPPING_NOTIFICATION_IDX_PAI_CHANGED, + + /*! Measurements changed notification. */ + MOD_POWER_CAPPING_NOTIFICATION_IDX_MEASUREMENTS_CHANGED, + /*! Number of defined notifications. */ MOD_POWER_CAPPING_NOTIFICATION_IDX_COUNT, }; diff --git a/module/power_capping/src/mod_power_capping.c b/module/power_capping/src/mod_power_capping.c index b56559ee61c8cb4d037d669b4eb3f7167d0f621a..d662e5110852d890ee4ebd202fde2a0e84ab5fae 100644 --- a/module/power_capping/src/mod_power_capping.c +++ b/module/power_capping/src/mod_power_capping.c @@ -246,6 +246,11 @@ static int mod_pcapping_get_power_limit( struct mod_power_capping_api pcapping_api = { .request_cap = mod_pcapping_request_cap, .get_applied_cap = mod_pcapping_get_applied_cap, + .get_average_power = mod_pcapping_get_average_power, + .get_averaging_interval = mod_pcapping_get_averaging_interval, + .get_averaging_interval_range = mod_pcapping_get_averaging_interval_range, + .get_averaging_interval_step = mod_pcapping_get_averaging_interval_step, + .set_averaging_interval = mod_pcapping_set_averaging_interval, }; struct interface_power_management_api power_management_api = { diff --git a/module/power_capping/test/mocks/Mockmod_power_capping_extra.c b/module/power_capping/test/mocks/Mockmod_power_capping_extra.c index 19ea351ec14841e6e4dcd11666150dcf4a1bae59..968cf3af4be910b7262865625c3cb28a1f343680 100644 --- a/module/power_capping/test/mocks/Mockmod_power_capping_extra.c +++ b/module/power_capping/test/mocks/Mockmod_power_capping_extra.c @@ -1700,4 +1700,3 @@ void set_point_CMockIgnoreArg_input(UNITY_LINE_TYPE cmock_line) UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_input = 1; } - diff --git a/module/power_coordinator/include/mod_power_coordinator.h b/module/power_coordinator/include/mod_power_coordinator.h deleted file mode 100644 index c0b7ac238118e1bec15c27615f84113fb258e3aa..0000000000000000000000000000000000000000 --- a/module/power_coordinator/include/mod_power_coordinator.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - * - * Description: - * Power coordinator module header. - */ - -#ifndef MOD_POWER_COORDINATOR_H -#define MOD_POWER_COORDINATOR_H - -#include - -#include - -/*! - * \addtogroup GroupModules Modules - * \{ - */ - -/*! - * \defgroup GroupPowerCoordinator Power coordinator - * - * \details Responsible for coordinating the modules related to the power - * management. - * - * \{ - */ - -/*! - * \brief Power coordinator interface. - */ -struct mod_power_coordinator_api { - /*! - * \brief Get the coordinator period. - * - * \param id Coordinator ID. - * \param[out] period The coordinator period. - * - * \retval ::FWK_SUCCESS The coordinator period is returned successfully. - */ - int (*get_coordinator_period)(fwk_id_t id, uint32_t *period); - - /*! - * \brief Set the coordinator period. - * - * \param id Coordinator ID. - * \param period The coordinator period. - * - * \retval ::FWK_SUCCESS The coordinator period is set successfully. - */ - int (*set_coordinator_period)(fwk_id_t id, uint32_t period); -}; - -/*! - * \brief API indices. - */ -enum mod_power_coordinator_api_idx { - /*! Power Coordinator period. */ - MOD_POWER_COORDINATOR_API_IDX_PERIOD, - - /*! Number of defined APIs. */ - MOD_POWER_COORDINATOR_API_IDX_COUNT, -}; - -/*! - * \brief Power coordinator notification indices. - */ -enum mod_power_coordinator_notification_idx { - /*! Period changed notification. */ - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_PERIOD_CHANGED, - - /*! Number of defined notifications. */ - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_COUNT, -}; - -/*! - * \} - */ - -/*! - * \} - */ -#endif /* MOD_POWER_COORDINATOR_H */ diff --git a/module/power_meter/include/mod_power_meter.h b/module/power_meter/include/mod_power_meter.h deleted file mode 100644 index 82afe3a4283c37c56a69ec8debe5c3ca6194827a..0000000000000000000000000000000000000000 --- a/module/power_meter/include/mod_power_meter.h +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - * - * Description: - * Power meter module header. - */ - -#ifndef MOD_POWER_METER_H -#define MOD_POWER_METER_H - -#include - -/*! - * \addtogroup GroupModules Modules - * \{ - */ - -/*! - * \defgroup GroupPowerMeter Power meter - * - * \details Responsible for power measurements - * - * \{ - */ - -/*! - * \brief Power meter device configuration. - */ -struct mod_power_meter_dev_config { - /*! - * \brief Module or element identifier of the driver - */ - fwk_id_t driver_id; - /*! - * \brief API identifier of the driver. - */ - fwk_id_t driver_api_id; -}; - -/*! - * \brief Power meter driver interface. - */ -struct mod_power_meter_driver_api { - /*! - * \brief Get the power measurement. - * - * \param id Specific power meter device ID. - * \param[out] power Power measured by the power meter device. - * - * \retval ::FWK_SUCCESS The cap is returned successfully. - */ - int (*get_power)(fwk_id_t id, uint32_t *power); -}; - -/*! - * \brief Power meter interface. - */ -struct mod_power_meter_api { - /*! - * \brief Get the power measurement. - * - * \param id Specific power meter device ID. - * \param[out] power Power measured by the power meter device. - * - * \retval ::FWK_SUCCESS The cap is returned successfully. - */ - int (*get_power)(fwk_id_t id, uint32_t *power); - - /*! - * \brief Set the power change notification hysteresis. - * - * \details The hysteresis is needed to avoid multiple unneeded - * notifications for a fluctuating power measurement. - * - * \param id Specific power meter device ID. - * \param threshold_low The lower threshold of the measured power to trigger - * a notification. - * - * \param threshold_high The higher threshold of the measured power to - * trigger a notification. - * - * \retval ::FWK_SUCCESS The threshold values are set successfully. - */ - int (*set_power_change_notif_thresholds)( - fwk_id_t id, - uint32_t threshold_low, - uint32_t threshold_high); -}; - -/*! - * \brief API indices. - */ -enum mod_power_meter_api_idx { - /*! Get power measurements */ - MOD_POWER_METER_API_IDX_MEASUREMENT, - - /*! Number of defined APIs. */ - MOD_POWER_METER_API_IDX_COUNT, -}; - -/*! - * \brief Power meter notification indices. - */ -enum mod_power_meter_notification_idx { - /*! Measured power changed notification. */ - MOD_POWER_METER_NOTIFICATION_IDX_MEASUREMENTS_CHANGED, - - /*! Number of defined notifications. */ - MOD_POWER_METER_NOTIFICATION_IDX_COUNT, -}; - -/*! - * \} - */ - -/*! - * \} - */ -#endif /* MOD_POWER_METER_H */ diff --git a/module/scmi_power_capping/CMakeLists.txt b/module/scmi_power_capping/CMakeLists.txt index 891d1879ce9fba918ec5f4794bdf2b04b24e81f7..a5a25ca4b3a4e356035e3f299811b03f04183cbe 100644 --- a/module/scmi_power_capping/CMakeLists.txt +++ b/module/scmi_power_capping/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -13,8 +13,6 @@ target_include_directories(${SCP_MODULE_TARGET} target_sources(${SCP_MODULE_TARGET} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_scmi_power_capping.c") -target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-meter) -target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-coordinator) target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-capping) if(SCP_EXCLUDE_SCMI_POWER_CAPPING_STD_COMMANDS AND diff --git a/module/scmi_power_capping/include/internal/scmi_power_capping.h b/module/scmi_power_capping/include/internal/scmi_power_capping.h index 2e55f1540dfb6a21eb7e7e6372cfe3fd661c3174..f0f8958a580b462bf2a07c19156bead2793be957 100644 --- a/module/scmi_power_capping/include/internal/scmi_power_capping.h +++ b/module/scmi_power_capping/include/internal/scmi_power_capping.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -12,8 +12,6 @@ #define INTERNAL_SCMI_POWER_CAPPING_H #include "mod_power_capping.h" -#include "mod_power_coordinator.h" -#include "mod_power_meter.h" #include "mod_scmi_power_capping.h" #include @@ -51,12 +49,6 @@ enum scmi_power_capping_event_idx { struct mod_scmi_power_capping_power_apis { /* Power capping API */ const struct mod_power_capping_api *power_capping_api; - - /* Power coordinator API */ - const struct mod_power_coordinator_api *power_coordinator_api; - - /* Power meter API */ - const struct mod_power_meter_api *power_meter_api; }; struct mod_scmi_power_capping_domain_context { @@ -100,11 +92,6 @@ struct mod_scmi_power_capping_domain_context { * \brief Power capping configuration support. */ bool cap_config_support; - - /*! - * \brief PAI configuration support. - */ - bool pai_config_support; }; struct mod_scmi_power_capping_context { diff --git a/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h b/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h index f0a1bc961fbbad43d7d555220ab94cf670108424..3fb190a6f5ad5bc2c6219baf5788c0e9242e2cf6 100644 --- a/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h +++ b/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -95,6 +95,9 @@ enum scmi_power_capping_notification_id { #define SCMI_POWER_CAPPING_DISABLE_CAP_VALUE ((uint32_t)0) #define SCMI_POWER_CAPPING_PAI_RESERVED_FLAG 0u + +#define UNSUPPORTED_CONFIG_PAI_VALUE 1u + /* * Power capping Domain attributes */ diff --git a/module/scmi_power_capping/include/mod_scmi_power_capping.h b/module/scmi_power_capping/include/mod_scmi_power_capping.h index e10b130f0958a3cfcaec5f1d8fdf00152e0d1898..4e4ec4dc1dc2e781afb482fba287ad789737ae68 100644 --- a/module/scmi_power_capping/include/mod_scmi_power_capping.h +++ b/module/scmi_power_capping/include/mod_scmi_power_capping.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -69,30 +69,6 @@ struct scmi_pcapping_fch_config { */ struct mod_scmi_power_capping_domain_config { #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS - /*! - * \brief Minimum PAI. - * - * \details The minimum supported power averaging interval (PAI), - * expressed in microseconds, its value cannot be zero. - */ - uint32_t min_pai; - - /*! - * \brief Maximum PAI. - * - * \details The maximum supported power averaging interval (PAI), - * expressed in microseconds, its value cannot be zero. - */ - uint32_t max_pai; - - /*! - * \brief PAI step. - * - * \details The step size between two consecutive PAI supported by - * this power capping domain. This value cannot be zero if min_pai and - * max_pai have different values. - */ - uint32_t pai_step; /*! * \brief Minimum power cap. * @@ -126,6 +102,11 @@ struct mod_scmi_power_capping_domain_config { */ uint32_t max_sustainable_power; + /*! + * \brief PAI configuration support. + */ + bool pai_config_support; + /*! * \brief Parent id. * diff --git a/module/scmi_power_capping/src/mod_scmi_power_capping.c b/module/scmi_power_capping/src/mod_scmi_power_capping.c index 5aecea23839eab6ce4990326a3815e7525b2d046..0e4de448418b8762a540a5f83d0bcfbacf0add74 100644 --- a/module/scmi_power_capping/src/mod_scmi_power_capping.c +++ b/module/scmi_power_capping/src/mod_scmi_power_capping.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -11,7 +11,6 @@ #include "fwk_module_idx.h" #include "internal/scmi_power_capping_protocol.h" #include "mod_power_capping.h" -#include "mod_power_meter.h" #ifdef BUILD_HAS_SCMI_POWER_CAPPING_FAST_CHANNELS_COMMANDS # include "internal/scmi_power_capping.h" @@ -32,33 +31,10 @@ static const fwk_id_t mod_scmi_power_capping_event_id_fch_callback = static int scmi_power_capping_power_api_bind( struct mod_scmi_power_capping_power_apis *power_apis) { - int status; - - status = fwk_module_bind( + return fwk_module_bind( FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), FWK_ID_API(FWK_MODULE_IDX_POWER_CAPPING, MOD_POWER_CAPPING_API_IDX_CAP), &(power_apis->power_capping_api)); - - if (status != FWK_SUCCESS) { - return status; - } - - status = fwk_module_bind( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), - FWK_ID_API( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_API_IDX_PERIOD), - &(power_apis->power_coordinator_api)); - - if (status != FWK_SUCCESS) { - return status; - } - - return fwk_module_bind( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), - FWK_ID_API( - FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT), - &(power_apis->power_meter_api)); } #ifdef BUILD_HAS_SCMI_NOTIFICATIONS diff --git a/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c b/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c index e8d6cc22c4862c7b95c198ff682f3e46cfd9084d..2538144380ee7db2388d4f9c2858d8dbbf8b6a0c 100644 --- a/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c +++ b/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -54,14 +54,6 @@ static fwk_id_t pcapping_fast_channel_get_power_capping_id(uint32_t domain_idx) .config->power_capping_domain_id; } -static fwk_id_t pcapping_fast_channel_get_power_coordinator_id( - uint32_t domain_idx) -{ - return pcapping_fast_channel_global_ctx - .power_capping_domain_ctx_table[domain_idx] - .config->power_coordinator_domain_id; -} - static void pcapping_fast_channel_callback(uintptr_t param) { int status; @@ -122,8 +114,8 @@ static void pcapping_fast_channel_get_pai( int status; status = pcapping_fast_channel_global_ctx.power_management_apis - ->power_coordinator_api->get_coordinator_period( - pcapping_fast_channel_get_power_coordinator_id(domain_idx), + ->power_capping_api->get_averaging_interval( + pcapping_fast_channel_get_power_capping_id(domain_idx), fch_addr); if (status != FWK_SUCCESS) { FWK_LOG_ERR("[SCMI-Power-Capping-Fast-Channel] Error getting PAI."); @@ -137,8 +129,8 @@ static void pcapping_fast_channel_set_pai( int status; status = pcapping_fast_channel_global_ctx.power_management_apis - ->power_coordinator_api->set_coordinator_period( - pcapping_fast_channel_get_power_coordinator_id(domain_idx), + ->power_capping_api->set_averaging_interval( + pcapping_fast_channel_get_power_capping_id(domain_idx), *fch_addr); if (status != FWK_SUCCESS) { FWK_LOG_ERR("[SCMI-Power-Capping-Fast-Channel] Error setting PAI."); diff --git a/module/scmi_power_capping/src/scmi_power_capping_protocol.c b/module/scmi_power_capping/src/scmi_power_capping_protocol.c index bdf94a51896b042374e1f30ac7e29d3df9f4a6f6..f75e1165f5671f15efd96ce6bba47a7fa480c079 100644 --- a/module/scmi_power_capping/src/scmi_power_capping_protocol.c +++ b/module/scmi_power_capping/src/scmi_power_capping_protocol.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -10,8 +10,6 @@ #include "internal/scmi_power_capping.h" #include "internal/scmi_power_capping_fast_channels.h" #include "internal/scmi_power_capping_protocol.h" -#include "mod_power_coordinator.h" -#include "mod_power_meter.h" #include #ifdef BUILD_HAS_MOD_RESOURCE_PERMS @@ -117,12 +115,12 @@ static const fwk_id_t pcapping_protocol_cap_notification = #ifdef BUILD_HAS_SCMI_NOTIFICATIONS static const fwk_id_t pcapping_protocol_pai_notification = FWK_ID_NOTIFICATION_INIT( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_PERIOD_CHANGED); + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_PAI_CHANGED); static const fwk_id_t pcapping_protocol_power_measurements_notification = FWK_ID_NOTIFICATION_INIT( - FWK_MODULE_IDX_POWER_METER, - MOD_POWER_METER_NOTIFICATION_IDX_MEASUREMENTS_CHANGED); + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_MEASUREMENTS_CHANGED); #endif static handler_table_t handler_table[MOD_SCMI_POWER_CAPPING_COMMAND_COUNT] = { @@ -239,6 +237,19 @@ static struct mod_scmi_power_capping_domain_context *get_domain_ctx( return &(pcapping_protocol_ctx.power_capping_domain_ctx_table[domain_idx]); } +/* + * Static helper function to set disabled pai values + */ +static void pcapping_protocol_set_disabled_pai_values( + uint32_t *pai_step, + uint32_t *min_pai, + uint32_t *max_pai) +{ + *pai_step = 0u; + *min_pai = UNSUPPORTED_CONFIG_PAI_VALUE; + *max_pai = UNSUPPORTED_CONFIG_PAI_VALUE; +} + /* * Static helper function to populate domain attributes return values. */ @@ -254,11 +265,8 @@ static inline void scmi_power_capping_populate_domain_attributes( return_values->attributes = SCMI_POWER_CAPPING_DOMAIN_ATTRIBUTES( domain_ctx->cap_config_support, - domain_ctx->pai_config_support, + config->pai_config_support, config->power_cap_unit); - return_values->min_pai = config->min_pai; - return_values->max_pai = config->max_pai; - return_values->pai_step = config->pai_step; #ifdef BUILD_HAS_SCMI_POWER_CAPPING_FAST_CHANNELS_COMMANDS return_values->attributes |= SCMI_POWER_CAPPING_DOMAIN_FCH_SUPPORT( @@ -272,11 +280,6 @@ static inline void scmi_power_capping_populate_domain_attributes( SCMI_POWER_CAPPING_DOMAIN_MEASUREMENTS_NOTIF_SUPPORT( config->power_measurements_change_notification_support); #endif - return_values->min_power_cap = config->min_power_cap; - return_values->max_power_cap = config->max_power_cap; - return_values->power_cap_step = config->power_cap_step; - return_values->max_sustainable_power = config->max_sustainable_power; - return_values->parent_id = config->parent_idx; } /* @@ -298,17 +301,10 @@ static int pcapping_protocol_check_domain_configuration( const struct mod_scmi_power_capping_domain_config *config) { if ((config->min_power_cap == (uint32_t)0) || - (config->max_power_cap == (uint32_t)0) || - (config->min_pai == (uint32_t)0) || (config->max_pai == (uint32_t)0)) { + (config->max_power_cap == (uint32_t)0)) { return FWK_E_DATA; } - if (config->min_pai != config->max_pai) { - if (config->pai_step == (uint32_t)0) { - return FWK_E_DATA; - } - } - if (config->min_power_cap != config->max_power_cap) { if (config->power_cap_step == (uint32_t)0) { return FWK_E_DATA; @@ -324,8 +320,6 @@ static void pcapping_protocol_set_cap_config_support( { domain_ctx->cap_config_support = (config->min_power_cap != config->max_power_cap); - - domain_ctx->pai_config_support = (config->min_pai != config->max_pai); } /* @@ -512,6 +506,10 @@ static int scmi_power_capping_domain_attributes_handler( { const struct scmi_power_capping_domain_attributes_a2p *parameters; struct scmi_power_capping_domain_attributes_p2a return_values = { 0 }; + const struct mod_scmi_power_capping_domain_context *domain_ctx; + const struct mod_scmi_power_capping_domain_config *config; + fwk_id_t domain_id; + int status; parameters = (const struct scmi_power_capping_domain_attributes_a2p *)payload; @@ -519,6 +517,43 @@ static int scmi_power_capping_domain_attributes_handler( scmi_power_capping_populate_domain_attributes( &return_values, parameters->domain_id); + domain_ctx = get_domain_ctx(parameters->domain_id); + config = domain_ctx->config; + + domain_id = domain_ctx->config->power_capping_domain_id; + + if (config->pai_config_support == false) { + pcapping_protocol_set_disabled_pai_values( + &return_values.pai_step, + &return_values.min_pai, + &return_values.max_pai); + } else { + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval_step( + domain_id, &return_values.pai_step); + + if (status != FWK_SUCCESS) { + return scmi_power_capping_respond_error( + service_id, SCMI_GENERIC_ERROR); + } + + status = + pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval_range( + domain_id, &return_values.min_pai, &return_values.max_pai); + + if (status != FWK_SUCCESS) { + return scmi_power_capping_respond_error( + service_id, SCMI_GENERIC_ERROR); + } + } + + return_values.min_power_cap = config->min_power_cap; + return_values.max_power_cap = config->max_power_cap; + return_values.power_cap_step = config->power_cap_step; + return_values.max_sustainable_power = config->max_sustainable_power; + return_values.parent_id = config->parent_idx; + fwk_str_strncpy( (char *)return_values.name, fwk_module_get_element_name(FWK_ID_ELEMENT( @@ -654,13 +689,15 @@ static int scmi_power_capping_pai_get_handler( struct mod_scmi_power_capping_domain_context *ctx; uint32_t pai; int status; + fwk_id_t domain_id; parameters = (const struct scmi_power_capping_pai_get_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->get_coordinator_period( - ctx->config->power_coordinator_domain_id, &pai); + domain_id = ctx->config->power_capping_domain_id; + + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval(domain_id, &pai); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); @@ -680,25 +717,23 @@ static int scmi_power_capping_pai_set_handler( const struct scmi_power_capping_pai_set_a2p *parameters; struct scmi_power_capping_pai_set_p2a return_values; struct mod_scmi_power_capping_domain_context *ctx; + const struct mod_scmi_power_capping_domain_config *config; int status; + fwk_id_t domain_id; parameters = (const struct scmi_power_capping_pai_set_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); + config = ctx->config; if (parameters->flags != SCMI_POWER_CAPPING_PAI_RESERVED_FLAG) { return scmi_power_capping_respond_error( service_id, SCMI_INVALID_PARAMETERS); } - if (!ctx->pai_config_support) { + if (!config->pai_config_support) { return scmi_power_capping_respond_error(service_id, SCMI_NOT_SUPPORTED); } - if ((parameters->pai < ctx->config->min_pai) || - (parameters->pai > ctx->config->max_pai)) { - return scmi_power_capping_respond_error(service_id, SCMI_OUT_OF_RANGE); - } - #ifdef BUILD_HAS_SCMI_NOTIFICATIONS if (ctx->config->cap_pai_change_notification_support) { if (!fwk_id_is_equal(ctx->pai_notification_service_id, FWK_ID_NONE)) { @@ -707,11 +742,16 @@ static int scmi_power_capping_pai_set_handler( } #endif - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->set_coordinator_period( - ctx->config->power_coordinator_domain_id, parameters->pai); + domain_id = ctx->config->power_capping_domain_id; + + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->set_averaging_interval(domain_id, parameters->pai); - if (status != FWK_SUCCESS) { + if (status == FWK_E_RANGE) { + return scmi_power_capping_respond_error(service_id, SCMI_OUT_OF_RANGE); + } else if (status == FWK_E_SUPPORT) { + return scmi_power_capping_respond_error(service_id, SCMI_NOT_SUPPORTED); + } else if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); } #ifdef BUILD_HAS_SCMI_NOTIFICATIONS @@ -736,22 +776,23 @@ static int scmi_power_capping_measurements_get_handler( int status; uint32_t power; uint32_t period; + fwk_id_t domain_id; parameters = (const struct scmi_power_capping_measurements_get_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); - status = - pcapping_protocol_ctx.power_management_apis->power_meter_api->get_power( - ctx->config->power_meter_domain_id, &power); + domain_id = ctx->config->power_capping_domain_id; + + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_average_power(domain_id, &power); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); } - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->get_coordinator_period( - ctx->config->power_coordinator_domain_id, &period); + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval(domain_id, &period); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); @@ -1065,7 +1106,7 @@ int pcapping_protocol_start(fwk_id_t id) status = fwk_notification_subscribe( pcapping_protocol_pai_notification, - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), id); if (status != FWK_SUCCESS) { @@ -1074,7 +1115,7 @@ int pcapping_protocol_start(fwk_id_t id) status = fwk_notification_subscribe( pcapping_protocol_power_measurements_notification, - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), id); if (status != FWK_SUCCESS) { @@ -1175,9 +1216,9 @@ int pcapping_protocol_process_cap_pai_notify_event( return status; } - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->get_coordinator_period( - ctx->config->power_coordinator_domain_id, &(payload.pai)); + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval( + ctx->config->power_capping_domain_id, &(payload.pai)); if (status != FWK_SUCCESS) { return status; @@ -1208,9 +1249,9 @@ int pcapping_protocol_process_measurements_notify_event( ctx = get_domain_ctx(event_params->domain_idx); - status = - pcapping_protocol_ctx.power_management_apis->power_meter_api->get_power( - ctx->config->power_meter_domain_id, &(payload.power)); + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_average_power( + ctx->config->power_capping_domain_id, &(payload.power)); if (status != FWK_SUCCESS) { return status; diff --git a/module/scmi_power_capping/test/CMakeLists.txt b/module/scmi_power_capping/test/CMakeLists.txt index fcf1fcca2d46630933f99ce65dc0dfe5c8b41336..c1fe68f0b9c707b95bd65940656ec8675cdbef12 100644 --- a/module/scmi_power_capping/test/CMakeLists.txt +++ b/module/scmi_power_capping/test/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -72,9 +72,7 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_POWER_CAPP target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_scmi_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_meter_extra.c) + ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c) ################################################################################ # Test scmi_power_capping_protocol.c + resource permissions # @@ -108,8 +106,6 @@ target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_scmi_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_meter_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_resource_perms_extra.c) ################################################################################ @@ -142,9 +138,7 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_NOTIFICATI target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_scmi_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_meter_extra.c) + ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c) ################################################################################ # Test scmi_power_capping_fast_channels.c with standard protocol commands # @@ -177,7 +171,6 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_POWER_CAPP target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_transport_extra.c) ################################################################################ @@ -210,5 +203,4 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_POWER_CAPP target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_transport_extra.c) diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c index 832d932fc83c54ace6685421fe4c5f7ac6ebd17d..5ef51c615680fb35eb658e4f9bee86f318f2f5f4 100644 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c +++ b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c @@ -8,7 +8,18 @@ static const char* CMockString_cap = "cap"; static const char* CMockString_domain_id = "domain_id"; static const char* CMockString_get_applied_cap = "get_applied_cap"; +static const char* CMockString_get_average_power = "get_average_power"; +static const char* CMockString_get_averaging_interval = "get_averaging_interval"; +static const char* CMockString_get_averaging_interval_range = "get_averaging_interval_range"; +static const char* CMockString_get_averaging_interval_step = "get_averaging_interval_step"; +static const char* CMockString_id = "id"; +static const char* CMockString_max_pai = "max_pai"; +static const char* CMockString_min_pai = "min_pai"; +static const char* CMockString_pai = "pai"; +static const char* CMockString_pai_step = "pai_step"; +static const char* CMockString_power = "power"; static const char* CMockString_request_cap = "request_cap"; +static const char* CMockString_set_averaging_interval = "set_averaging_interval"; typedef struct _CMOCK_get_applied_cap_CALL_INSTANCE { @@ -38,6 +49,88 @@ typedef struct _CMOCK_request_cap_CALL_INSTANCE } CMOCK_request_cap_CALL_INSTANCE; +typedef struct _CMOCK_get_average_power_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_power; + int Expected_power_Depth; + char ReturnThruPtr_power_Used; + uint32_t* ReturnThruPtr_power_Val; + size_t ReturnThruPtr_power_Size; + char IgnoreArg_id; + char IgnoreArg_power; + +} CMOCK_get_average_power_CALL_INSTANCE; + +typedef struct _CMOCK_set_averaging_interval_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t Expected_pai; + char IgnoreArg_id; + char IgnoreArg_pai; + +} CMOCK_set_averaging_interval_CALL_INSTANCE; + +typedef struct _CMOCK_get_averaging_interval_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_pai; + int Expected_pai_Depth; + char ReturnThruPtr_pai_Used; + uint32_t* ReturnThruPtr_pai_Val; + size_t ReturnThruPtr_pai_Size; + char IgnoreArg_id; + char IgnoreArg_pai; + +} CMOCK_get_averaging_interval_CALL_INSTANCE; + +typedef struct _CMOCK_get_averaging_interval_step_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_pai_step; + int Expected_pai_step_Depth; + char ReturnThruPtr_pai_step_Used; + uint32_t* ReturnThruPtr_pai_step_Val; + size_t ReturnThruPtr_pai_step_Size; + char IgnoreArg_id; + char IgnoreArg_pai_step; + +} CMOCK_get_averaging_interval_step_CALL_INSTANCE; + +typedef struct _CMOCK_get_averaging_interval_range_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_min_pai; + uint32_t* Expected_max_pai; + int Expected_min_pai_Depth; + int Expected_max_pai_Depth; + char ReturnThruPtr_min_pai_Used; + uint32_t* ReturnThruPtr_min_pai_Val; + size_t ReturnThruPtr_min_pai_Size; + char ReturnThruPtr_max_pai_Used; + uint32_t* ReturnThruPtr_max_pai_Val; + size_t ReturnThruPtr_max_pai_Size; + char IgnoreArg_id; + char IgnoreArg_min_pai; + char IgnoreArg_max_pai; + +} CMOCK_get_averaging_interval_range_CALL_INSTANCE; + static struct Mockmod_power_capping_extraInstance { char get_applied_cap_IgnoreBool; @@ -52,6 +145,36 @@ static struct Mockmod_power_capping_extraInstance CMOCK_request_cap_CALLBACK request_cap_CallbackFunctionPointer; int request_cap_CallbackCalls; CMOCK_MEM_INDEX_TYPE request_cap_CallInstance; + char get_average_power_IgnoreBool; + int get_average_power_FinalReturn; + char get_average_power_CallbackBool; + CMOCK_get_average_power_CALLBACK get_average_power_CallbackFunctionPointer; + int get_average_power_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_average_power_CallInstance; + char set_averaging_interval_IgnoreBool; + int set_averaging_interval_FinalReturn; + char set_averaging_interval_CallbackBool; + CMOCK_set_averaging_interval_CALLBACK set_averaging_interval_CallbackFunctionPointer; + int set_averaging_interval_CallbackCalls; + CMOCK_MEM_INDEX_TYPE set_averaging_interval_CallInstance; + char get_averaging_interval_IgnoreBool; + int get_averaging_interval_FinalReturn; + char get_averaging_interval_CallbackBool; + CMOCK_get_averaging_interval_CALLBACK get_averaging_interval_CallbackFunctionPointer; + int get_averaging_interval_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_averaging_interval_CallInstance; + char get_averaging_interval_step_IgnoreBool; + int get_averaging_interval_step_FinalReturn; + char get_averaging_interval_step_CallbackBool; + CMOCK_get_averaging_interval_step_CALLBACK get_averaging_interval_step_CallbackFunctionPointer; + int get_averaging_interval_step_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_averaging_interval_step_CallInstance; + char get_averaging_interval_range_IgnoreBool; + int get_averaging_interval_range_FinalReturn; + char get_averaging_interval_range_CallbackBool; + CMOCK_get_averaging_interval_range_CALLBACK get_averaging_interval_range_CallbackFunctionPointer; + int get_averaging_interval_range_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_averaging_interval_range_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -86,6 +209,71 @@ void Mockmod_power_capping_extra_Verify(void) call_instance = CMOCK_GUTS_NONE; (void)call_instance; } + call_instance = Mock.get_average_power_CallInstance; + if (Mock.get_average_power_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_average_power); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_average_power_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.set_averaging_interval_CallInstance; + if (Mock.set_averaging_interval_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_set_averaging_interval); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.set_averaging_interval_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_averaging_interval_CallInstance; + if (Mock.get_averaging_interval_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_averaging_interval); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_averaging_interval_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_averaging_interval_step_CallInstance; + if (Mock.get_averaging_interval_step_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_averaging_interval_step); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_averaging_interval_step_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_averaging_interval_range_CallInstance; + if (Mock.get_averaging_interval_range_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_averaging_interval_range); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_averaging_interval_range_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } } void Mockmod_power_capping_extra_Init(void) @@ -397,3 +585,833 @@ void request_cap_CMockIgnoreArg_cap(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_cap = 1; } +int get_average_power(fwk_id_t id, uint32_t* power) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_average_power); + cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_average_power_CallInstance); + Mock.get_average_power_CallInstance = CMock_Guts_MemNext(Mock.get_average_power_CallInstance); + if (Mock.get_average_power_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_average_power_FinalReturn; + Mock.get_average_power_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_average_power_CallbackBool && + Mock.get_average_power_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_average_power_CallbackFunctionPointer(id, power, Mock.get_average_power_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_average_power,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_power) + { + UNITY_SET_DETAILS(CMockString_get_average_power,CMockString_power); + if (cmock_call_instance->Expected_power == NULL) + { UNITY_TEST_ASSERT_NULL(power, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power, power, cmock_call_instance->Expected_power_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_average_power_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_average_power_CallbackFunctionPointer(id, power, Mock.get_average_power_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_power_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(power, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)power, (void*)cmock_call_instance->ReturnThruPtr_power_Val, + cmock_call_instance->ReturnThruPtr_power_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_average_power(CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power, int power_Depth); +void CMockExpectParameters_get_average_power(CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power, int power_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_power = power; + cmock_call_instance->Expected_power_Depth = power_Depth; + cmock_call_instance->IgnoreArg_power = 0; + cmock_call_instance->ReturnThruPtr_power_Used = 0; +} + +void get_average_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_average_power_IgnoreBool = (char)1; +} + +void get_average_power_CMockStopIgnore(void) +{ + if(Mock.get_average_power_IgnoreBool) + Mock.get_average_power_CallInstance = CMock_Guts_MemNext(Mock.get_average_power_CallInstance); + Mock.get_average_power_IgnoreBool = (char)0; +} + +void get_average_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_average_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_average_power(cmock_call_instance, id, power, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_average_power_AddCallback(CMOCK_get_average_power_CALLBACK Callback) +{ + Mock.get_average_power_IgnoreBool = (char)0; + Mock.get_average_power_CallbackBool = (char)1; + Mock.get_average_power_CallbackFunctionPointer = Callback; +} + +void get_average_power_Stub(CMOCK_get_average_power_CALLBACK Callback) +{ + Mock.get_average_power_IgnoreBool = (char)0; + Mock.get_average_power_CallbackBool = (char)0; + Mock.get_average_power_CallbackFunctionPointer = Callback; +} + +void get_average_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int power_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_average_power(cmock_call_instance, id, power, power_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_average_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size) +{ + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_average_power_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_power_Used = 1; + cmock_call_instance->ReturnThruPtr_power_Val = power; + cmock_call_instance->ReturnThruPtr_power_Size = cmock_size; +} + +void get_average_power_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_average_power_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_average_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_average_power_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_power = 1; +} + +int set_averaging_interval(fwk_id_t id, uint32_t pai) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_set_averaging_interval); + cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_averaging_interval_CallInstance); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.set_averaging_interval_CallInstance); + if (Mock.set_averaging_interval_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.set_averaging_interval_FinalReturn; + Mock.set_averaging_interval_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.set_averaging_interval_CallbackBool && + Mock.set_averaging_interval_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.set_averaging_interval_CallbackFunctionPointer(id, pai, Mock.set_averaging_interval_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_set_averaging_interval,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pai) + { + UNITY_SET_DETAILS(CMockString_set_averaging_interval,CMockString_pai); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_pai, pai, cmock_line, CMockStringMismatch); + } + } + if (Mock.set_averaging_interval_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.set_averaging_interval_CallbackFunctionPointer(id, pai, Mock.set_averaging_interval_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_set_averaging_interval(CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t pai); +void CMockExpectParameters_set_averaging_interval(CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t pai) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_pai = pai; + cmock_call_instance->IgnoreArg_pai = 0; +} + +void set_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_averaging_interval_CALL_INSTANCE)); + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.set_averaging_interval_CallInstance, cmock_guts_index); + Mock.set_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.set_averaging_interval_IgnoreBool = (char)1; +} + +void set_averaging_interval_CMockStopIgnore(void) +{ + if(Mock.set_averaging_interval_IgnoreBool) + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.set_averaging_interval_CallInstance); + Mock.set_averaging_interval_IgnoreBool = (char)0; +} + +void set_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_averaging_interval_CALL_INSTANCE)); + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.set_averaging_interval_CallInstance, cmock_guts_index); + Mock.set_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void set_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t pai, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_averaging_interval_CALL_INSTANCE)); + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.set_averaging_interval_CallInstance, cmock_guts_index); + Mock.set_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_set_averaging_interval(cmock_call_instance, id, pai); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void set_averaging_interval_AddCallback(CMOCK_set_averaging_interval_CALLBACK Callback) +{ + Mock.set_averaging_interval_IgnoreBool = (char)0; + Mock.set_averaging_interval_CallbackBool = (char)1; + Mock.set_averaging_interval_CallbackFunctionPointer = Callback; +} + +void set_averaging_interval_Stub(CMOCK_set_averaging_interval_CALLBACK Callback) +{ + Mock.set_averaging_interval_IgnoreBool = (char)0; + Mock.set_averaging_interval_CallbackBool = (char)0; + Mock.set_averaging_interval_CallbackFunctionPointer = Callback; +} + +void set_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void set_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pai = 1; +} + +int get_averaging_interval(fwk_id_t id, uint32_t* pai) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_averaging_interval); + cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_averaging_interval_CallInstance); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_CallInstance); + if (Mock.get_averaging_interval_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_averaging_interval_FinalReturn; + Mock.get_averaging_interval_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_averaging_interval_CallbackBool && + Mock.get_averaging_interval_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_averaging_interval_CallbackFunctionPointer(id, pai, Mock.get_averaging_interval_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pai) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval,CMockString_pai); + if (cmock_call_instance->Expected_pai == NULL) + { UNITY_TEST_ASSERT_NULL(pai, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pai, pai, cmock_call_instance->Expected_pai_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_averaging_interval_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_averaging_interval_CallbackFunctionPointer(id, pai, Mock.get_averaging_interval_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pai_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pai, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pai, (void*)cmock_call_instance->ReturnThruPtr_pai_Val, + cmock_call_instance->ReturnThruPtr_pai_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_averaging_interval(CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai, int pai_Depth); +void CMockExpectParameters_get_averaging_interval(CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai, int pai_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_pai = pai; + cmock_call_instance->Expected_pai_Depth = pai_Depth; + cmock_call_instance->IgnoreArg_pai = 0; + cmock_call_instance->ReturnThruPtr_pai_Used = 0; +} + +void get_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_averaging_interval_IgnoreBool = (char)1; +} + +void get_averaging_interval_CMockStopIgnore(void) +{ + if(Mock.get_averaging_interval_IgnoreBool) + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_CallInstance); + Mock.get_averaging_interval_IgnoreBool = (char)0; +} + +void get_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval(cmock_call_instance, id, pai, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_AddCallback(CMOCK_get_averaging_interval_CALLBACK Callback) +{ + Mock.get_averaging_interval_IgnoreBool = (char)0; + Mock.get_averaging_interval_CallbackBool = (char)1; + Mock.get_averaging_interval_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_Stub(CMOCK_get_averaging_interval_CALLBACK Callback) +{ + Mock.get_averaging_interval_IgnoreBool = (char)0; + Mock.get_averaging_interval_CallbackBool = (char)0; + Mock.get_averaging_interval_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int pai_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval(cmock_call_instance, id, pai, pai_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_CMockReturnMemThruPtr_pai(UNITY_LINE_TYPE cmock_line, uint32_t* pai, size_t cmock_size) +{ + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pai_Used = 1; + cmock_call_instance->ReturnThruPtr_pai_Val = pai; + cmock_call_instance->ReturnThruPtr_pai_Size = cmock_size; +} + +void get_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pai = 1; +} + +int get_averaging_interval_step(fwk_id_t id, uint32_t* pai_step) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_averaging_interval_step); + cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_averaging_interval_step_CallInstance); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_step_CallInstance); + if (Mock.get_averaging_interval_step_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_averaging_interval_step_FinalReturn; + Mock.get_averaging_interval_step_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_averaging_interval_step_CallbackBool && + Mock.get_averaging_interval_step_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_averaging_interval_step_CallbackFunctionPointer(id, pai_step, Mock.get_averaging_interval_step_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_step,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pai_step) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_step,CMockString_pai_step); + if (cmock_call_instance->Expected_pai_step == NULL) + { UNITY_TEST_ASSERT_NULL(pai_step, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pai_step, pai_step, cmock_call_instance->Expected_pai_step_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_averaging_interval_step_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_averaging_interval_step_CallbackFunctionPointer(id, pai_step, Mock.get_averaging_interval_step_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pai_step_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pai_step, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pai_step, (void*)cmock_call_instance->ReturnThruPtr_pai_step_Val, + cmock_call_instance->ReturnThruPtr_pai_step_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_averaging_interval_step(CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth); +void CMockExpectParameters_get_averaging_interval_step(CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_pai_step = pai_step; + cmock_call_instance->Expected_pai_step_Depth = pai_step_Depth; + cmock_call_instance->IgnoreArg_pai_step = 0; + cmock_call_instance->ReturnThruPtr_pai_step_Used = 0; +} + +void get_averaging_interval_step_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_averaging_interval_step_IgnoreBool = (char)1; +} + +void get_averaging_interval_step_CMockStopIgnore(void) +{ + if(Mock.get_averaging_interval_step_IgnoreBool) + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_step_CallInstance); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; +} + +void get_averaging_interval_step_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_averaging_interval_step_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_step(cmock_call_instance, id, pai_step, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_step_AddCallback(CMOCK_get_averaging_interval_step_CALLBACK Callback) +{ + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + Mock.get_averaging_interval_step_CallbackBool = (char)1; + Mock.get_averaging_interval_step_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_step_Stub(CMOCK_get_averaging_interval_step_CALLBACK Callback) +{ + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + Mock.get_averaging_interval_step_CallbackBool = (char)0; + Mock.get_averaging_interval_step_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_step_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_step(cmock_call_instance, id, pai_step, pai_step_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(UNITY_LINE_TYPE cmock_line, uint32_t* pai_step, size_t cmock_size) +{ + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_step_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pai_step_Used = 1; + cmock_call_instance->ReturnThruPtr_pai_step_Val = pai_step; + cmock_call_instance->ReturnThruPtr_pai_step_Size = cmock_size; +} + +void get_averaging_interval_step_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_step_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_averaging_interval_step_CMockIgnoreArg_pai_step(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_step_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pai_step = 1; +} + +int get_averaging_interval_range(fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_averaging_interval_range); + cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_averaging_interval_range_CallInstance); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_range_CallInstance); + if (Mock.get_averaging_interval_range_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_averaging_interval_range_FinalReturn; + Mock.get_averaging_interval_range_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_averaging_interval_range_CallbackBool && + Mock.get_averaging_interval_range_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_averaging_interval_range_CallbackFunctionPointer(id, min_pai, max_pai, Mock.get_averaging_interval_range_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_range,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_min_pai) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_range,CMockString_min_pai); + if (cmock_call_instance->Expected_min_pai == NULL) + { UNITY_TEST_ASSERT_NULL(min_pai, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_min_pai, min_pai, cmock_call_instance->Expected_min_pai_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_max_pai) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_range,CMockString_max_pai); + if (cmock_call_instance->Expected_max_pai == NULL) + { UNITY_TEST_ASSERT_NULL(max_pai, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_max_pai, max_pai, cmock_call_instance->Expected_max_pai_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_averaging_interval_range_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_averaging_interval_range_CallbackFunctionPointer(id, min_pai, max_pai, Mock.get_averaging_interval_range_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_min_pai_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(min_pai, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)min_pai, (void*)cmock_call_instance->ReturnThruPtr_min_pai_Val, + cmock_call_instance->ReturnThruPtr_min_pai_Size); + } + if (cmock_call_instance->ReturnThruPtr_max_pai_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(max_pai, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)max_pai, (void*)cmock_call_instance->ReturnThruPtr_max_pai_Val, + cmock_call_instance->ReturnThruPtr_max_pai_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_averaging_interval_range(CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth); +void CMockExpectParameters_get_averaging_interval_range(CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_min_pai = min_pai; + cmock_call_instance->Expected_min_pai_Depth = min_pai_Depth; + cmock_call_instance->IgnoreArg_min_pai = 0; + cmock_call_instance->ReturnThruPtr_min_pai_Used = 0; + cmock_call_instance->Expected_max_pai = max_pai; + cmock_call_instance->Expected_max_pai_Depth = max_pai_Depth; + cmock_call_instance->IgnoreArg_max_pai = 0; + cmock_call_instance->ReturnThruPtr_max_pai_Used = 0; +} + +void get_averaging_interval_range_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_averaging_interval_range_IgnoreBool = (char)1; +} + +void get_averaging_interval_range_CMockStopIgnore(void) +{ + if(Mock.get_averaging_interval_range_IgnoreBool) + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_range_CallInstance); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; +} + +void get_averaging_interval_range_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_averaging_interval_range_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_range(cmock_call_instance, id, min_pai, 1, max_pai, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_range_AddCallback(CMOCK_get_averaging_interval_range_CALLBACK Callback) +{ + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + Mock.get_averaging_interval_range_CallbackBool = (char)1; + Mock.get_averaging_interval_range_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_range_Stub(CMOCK_get_averaging_interval_range_CALLBACK Callback) +{ + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + Mock.get_averaging_interval_range_CallbackBool = (char)0; + Mock.get_averaging_interval_range_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_range_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_range(cmock_call_instance, id, min_pai, min_pai_Depth, max_pai, max_pai_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(UNITY_LINE_TYPE cmock_line, uint32_t* min_pai, size_t cmock_size) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_min_pai_Used = 1; + cmock_call_instance->ReturnThruPtr_min_pai_Val = min_pai; + cmock_call_instance->ReturnThruPtr_min_pai_Size = cmock_size; +} + +void get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(UNITY_LINE_TYPE cmock_line, uint32_t* max_pai, size_t cmock_size) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_max_pai_Used = 1; + cmock_call_instance->ReturnThruPtr_max_pai_Val = max_pai; + cmock_call_instance->ReturnThruPtr_max_pai_Size = cmock_size; +} + +void get_averaging_interval_range_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_averaging_interval_range_CMockIgnoreArg_min_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_min_pai = 1; +} + +void get_averaging_interval_range_CMockIgnoreArg_max_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_max_pai = 1; +} + diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h index 9ae843d1691e1bfc333f43c62b1a9e15c77e127d..71ea7b54be425032f91eeeb834ec57f02f818a39 100644 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h +++ b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h @@ -62,6 +62,116 @@ void request_cap_Stub(CMOCK_request_cap_CALLBACK Callback); void request_cap_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); #define request_cap_IgnoreArg_cap() request_cap_CMockIgnoreArg_cap(__LINE__) void request_cap_CMockIgnoreArg_cap(UNITY_LINE_TYPE cmock_line); +#define get_average_power_IgnoreAndReturn(cmock_retval) get_average_power_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_average_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_average_power_StopIgnore() get_average_power_CMockStopIgnore() +void get_average_power_CMockStopIgnore(void); +#define get_average_power_ExpectAnyArgsAndReturn(cmock_retval) get_average_power_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_average_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_average_power_ExpectAndReturn(id, power, cmock_retval) get_average_power_CMockExpectAndReturn(__LINE__, id, power, cmock_retval) +void get_average_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int cmock_to_return); +typedef int (* CMOCK_get_average_power_CALLBACK)(fwk_id_t id, uint32_t* power, int cmock_num_calls); +void get_average_power_AddCallback(CMOCK_get_average_power_CALLBACK Callback); +void get_average_power_Stub(CMOCK_get_average_power_CALLBACK Callback); +#define get_average_power_StubWithCallback get_average_power_Stub +#define get_average_power_ExpectWithArrayAndReturn(id, power, power_Depth, cmock_retval) get_average_power_CMockExpectWithArrayAndReturn(__LINE__, id, power, power_Depth, cmock_retval) +void get_average_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int power_Depth, int cmock_to_return); +#define get_average_power_ReturnThruPtr_power(power) get_average_power_CMockReturnMemThruPtr_power(__LINE__, power, sizeof(uint32_t)) +#define get_average_power_ReturnArrayThruPtr_power(power, cmock_len) get_average_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_len * sizeof(*power)) +#define get_average_power_ReturnMemThruPtr_power(power, cmock_size) get_average_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_size) +void get_average_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size); +#define get_average_power_IgnoreArg_id() get_average_power_CMockIgnoreArg_id(__LINE__) +void get_average_power_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_average_power_IgnoreArg_power() get_average_power_CMockIgnoreArg_power(__LINE__) +void get_average_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line); +#define set_averaging_interval_IgnoreAndReturn(cmock_retval) set_averaging_interval_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void set_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_averaging_interval_StopIgnore() set_averaging_interval_CMockStopIgnore() +void set_averaging_interval_CMockStopIgnore(void); +#define set_averaging_interval_ExpectAnyArgsAndReturn(cmock_retval) set_averaging_interval_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void set_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_averaging_interval_ExpectAndReturn(id, pai, cmock_retval) set_averaging_interval_CMockExpectAndReturn(__LINE__, id, pai, cmock_retval) +void set_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t pai, int cmock_to_return); +typedef int (* CMOCK_set_averaging_interval_CALLBACK)(fwk_id_t id, uint32_t pai, int cmock_num_calls); +void set_averaging_interval_AddCallback(CMOCK_set_averaging_interval_CALLBACK Callback); +void set_averaging_interval_Stub(CMOCK_set_averaging_interval_CALLBACK Callback); +#define set_averaging_interval_StubWithCallback set_averaging_interval_Stub +#define set_averaging_interval_IgnoreArg_id() set_averaging_interval_CMockIgnoreArg_id(__LINE__) +void set_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define set_averaging_interval_IgnoreArg_pai() set_averaging_interval_CMockIgnoreArg_pai(__LINE__) +void set_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_IgnoreAndReturn(cmock_retval) get_averaging_interval_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_StopIgnore() get_averaging_interval_CMockStopIgnore() +void get_averaging_interval_CMockStopIgnore(void); +#define get_averaging_interval_ExpectAnyArgsAndReturn(cmock_retval) get_averaging_interval_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_ExpectAndReturn(id, pai, cmock_retval) get_averaging_interval_CMockExpectAndReturn(__LINE__, id, pai, cmock_retval) +void get_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int cmock_to_return); +typedef int (* CMOCK_get_averaging_interval_CALLBACK)(fwk_id_t id, uint32_t* pai, int cmock_num_calls); +void get_averaging_interval_AddCallback(CMOCK_get_averaging_interval_CALLBACK Callback); +void get_averaging_interval_Stub(CMOCK_get_averaging_interval_CALLBACK Callback); +#define get_averaging_interval_StubWithCallback get_averaging_interval_Stub +#define get_averaging_interval_ExpectWithArrayAndReturn(id, pai, pai_Depth, cmock_retval) get_averaging_interval_CMockExpectWithArrayAndReturn(__LINE__, id, pai, pai_Depth, cmock_retval) +void get_averaging_interval_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int pai_Depth, int cmock_to_return); +#define get_averaging_interval_ReturnThruPtr_pai(pai) get_averaging_interval_CMockReturnMemThruPtr_pai(__LINE__, pai, sizeof(uint32_t)) +#define get_averaging_interval_ReturnArrayThruPtr_pai(pai, cmock_len) get_averaging_interval_CMockReturnMemThruPtr_pai(__LINE__, pai, cmock_len * sizeof(*pai)) +#define get_averaging_interval_ReturnMemThruPtr_pai(pai, cmock_size) get_averaging_interval_CMockReturnMemThruPtr_pai(__LINE__, pai, cmock_size) +void get_averaging_interval_CMockReturnMemThruPtr_pai(UNITY_LINE_TYPE cmock_line, uint32_t* pai, size_t cmock_size); +#define get_averaging_interval_IgnoreArg_id() get_averaging_interval_CMockIgnoreArg_id(__LINE__) +void get_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_IgnoreArg_pai() get_averaging_interval_CMockIgnoreArg_pai(__LINE__) +void get_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_step_IgnoreAndReturn(cmock_retval) get_averaging_interval_step_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_step_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_step_StopIgnore() get_averaging_interval_step_CMockStopIgnore() +void get_averaging_interval_step_CMockStopIgnore(void); +#define get_averaging_interval_step_ExpectAnyArgsAndReturn(cmock_retval) get_averaging_interval_step_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_step_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_step_ExpectAndReturn(id, pai_step, cmock_retval) get_averaging_interval_step_CMockExpectAndReturn(__LINE__, id, pai_step, cmock_retval) +void get_averaging_interval_step_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int cmock_to_return); +typedef int (* CMOCK_get_averaging_interval_step_CALLBACK)(fwk_id_t id, uint32_t* pai_step, int cmock_num_calls); +void get_averaging_interval_step_AddCallback(CMOCK_get_averaging_interval_step_CALLBACK Callback); +void get_averaging_interval_step_Stub(CMOCK_get_averaging_interval_step_CALLBACK Callback); +#define get_averaging_interval_step_StubWithCallback get_averaging_interval_step_Stub +#define get_averaging_interval_step_ExpectWithArrayAndReturn(id, pai_step, pai_step_Depth, cmock_retval) get_averaging_interval_step_CMockExpectWithArrayAndReturn(__LINE__, id, pai_step, pai_step_Depth, cmock_retval) +void get_averaging_interval_step_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth, int cmock_to_return); +#define get_averaging_interval_step_ReturnThruPtr_pai_step(pai_step) get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(__LINE__, pai_step, sizeof(uint32_t)) +#define get_averaging_interval_step_ReturnArrayThruPtr_pai_step(pai_step, cmock_len) get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(__LINE__, pai_step, cmock_len * sizeof(*pai_step)) +#define get_averaging_interval_step_ReturnMemThruPtr_pai_step(pai_step, cmock_size) get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(__LINE__, pai_step, cmock_size) +void get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(UNITY_LINE_TYPE cmock_line, uint32_t* pai_step, size_t cmock_size); +#define get_averaging_interval_step_IgnoreArg_id() get_averaging_interval_step_CMockIgnoreArg_id(__LINE__) +void get_averaging_interval_step_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_step_IgnoreArg_pai_step() get_averaging_interval_step_CMockIgnoreArg_pai_step(__LINE__) +void get_averaging_interval_step_CMockIgnoreArg_pai_step(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_range_IgnoreAndReturn(cmock_retval) get_averaging_interval_range_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_range_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_range_StopIgnore() get_averaging_interval_range_CMockStopIgnore() +void get_averaging_interval_range_CMockStopIgnore(void); +#define get_averaging_interval_range_ExpectAnyArgsAndReturn(cmock_retval) get_averaging_interval_range_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_range_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_range_ExpectAndReturn(id, min_pai, max_pai, cmock_retval) get_averaging_interval_range_CMockExpectAndReturn(__LINE__, id, min_pai, max_pai, cmock_retval) +void get_averaging_interval_range_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai, int cmock_to_return); +typedef int (* CMOCK_get_averaging_interval_range_CALLBACK)(fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai, int cmock_num_calls); +void get_averaging_interval_range_AddCallback(CMOCK_get_averaging_interval_range_CALLBACK Callback); +void get_averaging_interval_range_Stub(CMOCK_get_averaging_interval_range_CALLBACK Callback); +#define get_averaging_interval_range_StubWithCallback get_averaging_interval_range_Stub +#define get_averaging_interval_range_ExpectWithArrayAndReturn(id, min_pai, min_pai_Depth, max_pai, max_pai_Depth, cmock_retval) get_averaging_interval_range_CMockExpectWithArrayAndReturn(__LINE__, id, min_pai, min_pai_Depth, max_pai, max_pai_Depth, cmock_retval) +void get_averaging_interval_range_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth, int cmock_to_return); +#define get_averaging_interval_range_ReturnThruPtr_min_pai(min_pai) get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(__LINE__, min_pai, sizeof(uint32_t)) +#define get_averaging_interval_range_ReturnArrayThruPtr_min_pai(min_pai, cmock_len) get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(__LINE__, min_pai, cmock_len * sizeof(*min_pai)) +#define get_averaging_interval_range_ReturnMemThruPtr_min_pai(min_pai, cmock_size) get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(__LINE__, min_pai, cmock_size) +void get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(UNITY_LINE_TYPE cmock_line, uint32_t* min_pai, size_t cmock_size); +#define get_averaging_interval_range_ReturnThruPtr_max_pai(max_pai) get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(__LINE__, max_pai, sizeof(uint32_t)) +#define get_averaging_interval_range_ReturnArrayThruPtr_max_pai(max_pai, cmock_len) get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(__LINE__, max_pai, cmock_len * sizeof(*max_pai)) +#define get_averaging_interval_range_ReturnMemThruPtr_max_pai(max_pai, cmock_size) get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(__LINE__, max_pai, cmock_size) +void get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(UNITY_LINE_TYPE cmock_line, uint32_t* max_pai, size_t cmock_size); +#define get_averaging_interval_range_IgnoreArg_id() get_averaging_interval_range_CMockIgnoreArg_id(__LINE__) +void get_averaging_interval_range_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_range_IgnoreArg_min_pai() get_averaging_interval_range_CMockIgnoreArg_min_pai(__LINE__) +void get_averaging_interval_range_CMockIgnoreArg_min_pai(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_range_IgnoreArg_max_pai() get_averaging_interval_range_CMockIgnoreArg_max_pai(__LINE__) +void get_averaging_interval_range_CMockIgnoreArg_max_pai(UNITY_LINE_TYPE cmock_line); #if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) #if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c b/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c deleted file mode 100644 index 56408a555817e2e3809f13c699c9eeefff09e552..0000000000000000000000000000000000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c +++ /dev/null @@ -1,399 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#include -#include -#include -#include "cmock.h" -#include "Mockmod_power_coordinator_extra.h" - -static const char* CMockString_domain_id = "domain_id"; -static const char* CMockString_get_coordinator_period = "get_coordinator_period"; -static const char* CMockString_period = "period"; -static const char* CMockString_set_coordinator_period = "set_coordinator_period"; - -typedef struct _CMOCK_get_coordinator_period_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_domain_id; - uint32_t* Expected_period; - int Expected_period_Depth; - char ReturnThruPtr_period_Used; - uint32_t* ReturnThruPtr_period_Val; - size_t ReturnThruPtr_period_Size; - char IgnoreArg_domain_id; - char IgnoreArg_period; - -} CMOCK_get_coordinator_period_CALL_INSTANCE; - -typedef struct _CMOCK_set_coordinator_period_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_domain_id; - uint32_t Expected_period; - char IgnoreArg_domain_id; - char IgnoreArg_period; - -} CMOCK_set_coordinator_period_CALL_INSTANCE; - -static struct Mockmod_power_coordinator_extraInstance -{ - char get_coordinator_period_IgnoreBool; - int get_coordinator_period_FinalReturn; - char get_coordinator_period_CallbackBool; - CMOCK_get_coordinator_period_CALLBACK get_coordinator_period_CallbackFunctionPointer; - int get_coordinator_period_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_coordinator_period_CallInstance; - char set_coordinator_period_IgnoreBool; - int set_coordinator_period_FinalReturn; - char set_coordinator_period_CallbackBool; - CMOCK_set_coordinator_period_CALLBACK set_coordinator_period_CallbackFunctionPointer; - int set_coordinator_period_CallbackCalls; - CMOCK_MEM_INDEX_TYPE set_coordinator_period_CallInstance; -} Mock; - -extern jmp_buf AbortFrame; - -void Mockmod_power_coordinator_extra_Verify(void) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_MEM_INDEX_TYPE call_instance; - call_instance = Mock.get_coordinator_period_CallInstance; - if (Mock.get_coordinator_period_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_get_coordinator_period); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.get_coordinator_period_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } - call_instance = Mock.set_coordinator_period_CallInstance; - if (Mock.set_coordinator_period_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_set_coordinator_period); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.set_coordinator_period_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } -} - -void Mockmod_power_coordinator_extra_Init(void) -{ - Mockmod_power_coordinator_extra_Destroy(); -} - -void Mockmod_power_coordinator_extra_Destroy(void) -{ - CMock_Guts_MemFreeAll(); - memset(&Mock, 0, sizeof(Mock)); -} - -int get_coordinator_period(fwk_id_t domain_id, uint32_t* period) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_coordinator_period); - cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_coordinator_period_CallInstance); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.get_coordinator_period_CallInstance); - if (Mock.get_coordinator_period_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.get_coordinator_period_FinalReturn; - Mock.get_coordinator_period_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.get_coordinator_period_CallbackBool && - Mock.get_coordinator_period_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.get_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.get_coordinator_period_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_domain_id) - { - UNITY_SET_DETAILS(CMockString_get_coordinator_period,CMockString_domain_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_period) - { - UNITY_SET_DETAILS(CMockString_get_coordinator_period,CMockString_period); - if (cmock_call_instance->Expected_period == NULL) - { UNITY_TEST_ASSERT_NULL(period, cmock_line, CMockStringExpNULL); } - else - { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_period, period, cmock_call_instance->Expected_period_Depth, cmock_line, CMockStringMismatch); } - } - } - if (Mock.get_coordinator_period_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.get_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.get_coordinator_period_CallbackCalls++); - } - if (cmock_call_instance->ReturnThruPtr_period_Used) - { - UNITY_TEST_ASSERT_NOT_NULL(period, cmock_line, CMockStringPtrIsNULL); - memcpy((void*)period, (void*)cmock_call_instance->ReturnThruPtr_period_Val, - cmock_call_instance->ReturnThruPtr_period_Size); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_get_coordinator_period(CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* period, int period_Depth); -void CMockExpectParameters_get_coordinator_period(CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* period, int period_Depth) -{ - memcpy((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), - sizeof(fwk_id_t[sizeof(domain_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_domain_id = 0; - cmock_call_instance->Expected_period = period; - cmock_call_instance->Expected_period_Depth = period_Depth; - cmock_call_instance->IgnoreArg_period = 0; - cmock_call_instance->ReturnThruPtr_period_Used = 0; -} - -void get_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_coordinator_period_IgnoreBool = (char)1; -} - -void get_coordinator_period_CMockStopIgnore(void) -{ - if(Mock.get_coordinator_period_IgnoreBool) - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.get_coordinator_period_CallInstance); - Mock.get_coordinator_period_IgnoreBool = (char)0; -} - -void get_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void get_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_coordinator_period(cmock_call_instance, domain_id, period, 1); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_coordinator_period_AddCallback(CMOCK_get_coordinator_period_CALLBACK Callback) -{ - Mock.get_coordinator_period_IgnoreBool = (char)0; - Mock.get_coordinator_period_CallbackBool = (char)1; - Mock.get_coordinator_period_CallbackFunctionPointer = Callback; -} - -void get_coordinator_period_Stub(CMOCK_get_coordinator_period_CALLBACK Callback) -{ - Mock.get_coordinator_period_IgnoreBool = (char)0; - Mock.get_coordinator_period_CallbackBool = (char)0; - Mock.get_coordinator_period_CallbackFunctionPointer = Callback; -} - -void get_coordinator_period_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int period_Depth, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_coordinator_period(cmock_call_instance, domain_id, period, period_Depth); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_coordinator_period_CMockReturnMemThruPtr_period(UNITY_LINE_TYPE cmock_line, uint32_t* period, size_t cmock_size) -{ - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); - cmock_call_instance->ReturnThruPtr_period_Used = 1; - cmock_call_instance->ReturnThruPtr_period_Val = period; - cmock_call_instance->ReturnThruPtr_period_Size = cmock_size; -} - -void get_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_domain_id = 1; -} - -void get_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_period = 1; -} - -int set_coordinator_period(fwk_id_t domain_id, uint32_t period) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_set_coordinator_period); - cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_coordinator_period_CallInstance); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.set_coordinator_period_CallInstance); - if (Mock.set_coordinator_period_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.set_coordinator_period_FinalReturn; - Mock.set_coordinator_period_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.set_coordinator_period_CallbackBool && - Mock.set_coordinator_period_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.set_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.set_coordinator_period_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_domain_id) - { - UNITY_SET_DETAILS(CMockString_set_coordinator_period,CMockString_domain_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_period) - { - UNITY_SET_DETAILS(CMockString_set_coordinator_period,CMockString_period); - UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_period, period, cmock_line, CMockStringMismatch); - } - } - if (Mock.set_coordinator_period_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.set_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.set_coordinator_period_CallbackCalls++); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_set_coordinator_period(CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t period); -void CMockExpectParameters_set_coordinator_period(CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t period) -{ - memcpy((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), - sizeof(fwk_id_t[sizeof(domain_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_domain_id = 0; - cmock_call_instance->Expected_period = period; - cmock_call_instance->IgnoreArg_period = 0; -} - -void set_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_coordinator_period_CALL_INSTANCE)); - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.set_coordinator_period_CallInstance, cmock_guts_index); - Mock.set_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.set_coordinator_period_IgnoreBool = (char)1; -} - -void set_coordinator_period_CMockStopIgnore(void) -{ - if(Mock.set_coordinator_period_IgnoreBool) - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.set_coordinator_period_CallInstance); - Mock.set_coordinator_period_IgnoreBool = (char)0; -} - -void set_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_coordinator_period_CALL_INSTANCE)); - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.set_coordinator_period_CallInstance, cmock_guts_index); - Mock.set_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void set_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t period, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_coordinator_period_CALL_INSTANCE)); - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.set_coordinator_period_CallInstance, cmock_guts_index); - Mock.set_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_set_coordinator_period(cmock_call_instance, domain_id, period); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void set_coordinator_period_AddCallback(CMOCK_set_coordinator_period_CALLBACK Callback) -{ - Mock.set_coordinator_period_IgnoreBool = (char)0; - Mock.set_coordinator_period_CallbackBool = (char)1; - Mock.set_coordinator_period_CallbackFunctionPointer = Callback; -} - -void set_coordinator_period_Stub(CMOCK_set_coordinator_period_CALLBACK Callback) -{ - Mock.set_coordinator_period_IgnoreBool = (char)0; - Mock.set_coordinator_period_CallbackBool = (char)0; - Mock.set_coordinator_period_CallbackFunctionPointer = Callback; -} - -void set_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_domain_id = 1; -} - -void set_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_period = 1; -} - diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h b/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h deleted file mode 100644 index 7d73f6fe39f6d291bb851f7b033e1948676cc9f6..0000000000000000000000000000000000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h +++ /dev/null @@ -1,72 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#ifndef _MOCKMOD_POWER_COORDINATOR_EXTRA_H -#define _MOCKMOD_POWER_COORDINATOR_EXTRA_H - -#include "unity.h" -#include "mod_power_coordinator_extra.h" - -/* Ignore the following warnings, since we are copying code */ -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic push -#endif -#if !defined(__clang__) -#pragma GCC diagnostic ignored "-Wpragmas" -#endif -#pragma GCC diagnostic ignored "-Wunknown-pragmas" -#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" -#endif - -void Mockmod_power_coordinator_extra_Init(void); -void Mockmod_power_coordinator_extra_Destroy(void); -void Mockmod_power_coordinator_extra_Verify(void); - - - - -#define get_coordinator_period_IgnoreAndReturn(cmock_retval) get_coordinator_period_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_coordinator_period_StopIgnore() get_coordinator_period_CMockStopIgnore() -void get_coordinator_period_CMockStopIgnore(void); -#define get_coordinator_period_ExpectAnyArgsAndReturn(cmock_retval) get_coordinator_period_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_coordinator_period_ExpectAndReturn(domain_id, period, cmock_retval) get_coordinator_period_CMockExpectAndReturn(__LINE__, domain_id, period, cmock_retval) -void get_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int cmock_to_return); -typedef int (* CMOCK_get_coordinator_period_CALLBACK)(fwk_id_t domain_id, uint32_t* period, int cmock_num_calls); -void get_coordinator_period_AddCallback(CMOCK_get_coordinator_period_CALLBACK Callback); -void get_coordinator_period_Stub(CMOCK_get_coordinator_period_CALLBACK Callback); -#define get_coordinator_period_StubWithCallback get_coordinator_period_Stub -#define get_coordinator_period_ExpectWithArrayAndReturn(domain_id, period, period_Depth, cmock_retval) get_coordinator_period_CMockExpectWithArrayAndReturn(__LINE__, domain_id, period, period_Depth, cmock_retval) -void get_coordinator_period_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int period_Depth, int cmock_to_return); -#define get_coordinator_period_ReturnThruPtr_period(period) get_coordinator_period_CMockReturnMemThruPtr_period(__LINE__, period, sizeof(uint32_t)) -#define get_coordinator_period_ReturnArrayThruPtr_period(period, cmock_len) get_coordinator_period_CMockReturnMemThruPtr_period(__LINE__, period, cmock_len * sizeof(*period)) -#define get_coordinator_period_ReturnMemThruPtr_period(period, cmock_size) get_coordinator_period_CMockReturnMemThruPtr_period(__LINE__, period, cmock_size) -void get_coordinator_period_CMockReturnMemThruPtr_period(UNITY_LINE_TYPE cmock_line, uint32_t* period, size_t cmock_size); -#define get_coordinator_period_IgnoreArg_domain_id() get_coordinator_period_CMockIgnoreArg_domain_id(__LINE__) -void get_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); -#define get_coordinator_period_IgnoreArg_period() get_coordinator_period_CMockIgnoreArg_period(__LINE__) -void get_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line); -#define set_coordinator_period_IgnoreAndReturn(cmock_retval) set_coordinator_period_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void set_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_coordinator_period_StopIgnore() set_coordinator_period_CMockStopIgnore() -void set_coordinator_period_CMockStopIgnore(void); -#define set_coordinator_period_ExpectAnyArgsAndReturn(cmock_retval) set_coordinator_period_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void set_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_coordinator_period_ExpectAndReturn(domain_id, period, cmock_retval) set_coordinator_period_CMockExpectAndReturn(__LINE__, domain_id, period, cmock_retval) -void set_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t period, int cmock_to_return); -typedef int (* CMOCK_set_coordinator_period_CALLBACK)(fwk_id_t domain_id, uint32_t period, int cmock_num_calls); -void set_coordinator_period_AddCallback(CMOCK_set_coordinator_period_CALLBACK Callback); -void set_coordinator_period_Stub(CMOCK_set_coordinator_period_CALLBACK Callback); -#define set_coordinator_period_StubWithCallback set_coordinator_period_Stub -#define set_coordinator_period_IgnoreArg_domain_id() set_coordinator_period_CMockIgnoreArg_domain_id(__LINE__) -void set_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); -#define set_coordinator_period_IgnoreArg_period() set_coordinator_period_CMockIgnoreArg_period(__LINE__) -void set_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line); - -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic pop -#endif -#endif - -#endif diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c b/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c deleted file mode 100644 index e1d69678d7fd113bd657d722fcc3282e1e601a22..0000000000000000000000000000000000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c +++ /dev/null @@ -1,418 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#include -#include -#include -#include "cmock.h" -#include "Mockmod_power_meter_extra.h" - -static const char* CMockString_domain_id = "domain_id"; -static const char* CMockString_get_power = "get_power"; -static const char* CMockString_id = "id"; -static const char* CMockString_power = "power"; -static const char* CMockString_set_power_change_notif_thresholds = "set_power_change_notif_thresholds"; -static const char* CMockString_threshold_high = "threshold_high"; -static const char* CMockString_threshold_low = "threshold_low"; - -typedef struct _CMOCK_get_power_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_domain_id; - uint32_t* Expected_power; - int Expected_power_Depth; - char ReturnThruPtr_power_Used; - uint32_t* ReturnThruPtr_power_Val; - size_t ReturnThruPtr_power_Size; - char IgnoreArg_domain_id; - char IgnoreArg_power; - -} CMOCK_get_power_CALL_INSTANCE; - -typedef struct _CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_id; - uint32_t Expected_threshold_low; - uint32_t Expected_threshold_high; - char IgnoreArg_id; - char IgnoreArg_threshold_low; - char IgnoreArg_threshold_high; - -} CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE; - -static struct Mockmod_power_meter_extraInstance -{ - char get_power_IgnoreBool; - int get_power_FinalReturn; - char get_power_CallbackBool; - CMOCK_get_power_CALLBACK get_power_CallbackFunctionPointer; - int get_power_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_power_CallInstance; - char set_power_change_notif_thresholds_IgnoreBool; - int set_power_change_notif_thresholds_FinalReturn; - char set_power_change_notif_thresholds_CallbackBool; - CMOCK_set_power_change_notif_thresholds_CALLBACK set_power_change_notif_thresholds_CallbackFunctionPointer; - int set_power_change_notif_thresholds_CallbackCalls; - CMOCK_MEM_INDEX_TYPE set_power_change_notif_thresholds_CallInstance; -} Mock; - -extern jmp_buf AbortFrame; - -void Mockmod_power_meter_extra_Verify(void) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_MEM_INDEX_TYPE call_instance; - call_instance = Mock.get_power_CallInstance; - if (Mock.get_power_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_get_power); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.get_power_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } - call_instance = Mock.set_power_change_notif_thresholds_CallInstance; - if (Mock.set_power_change_notif_thresholds_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_set_power_change_notif_thresholds); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.set_power_change_notif_thresholds_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } -} - -void Mockmod_power_meter_extra_Init(void) -{ - Mockmod_power_meter_extra_Destroy(); -} - -void Mockmod_power_meter_extra_Destroy(void) -{ - CMock_Guts_MemFreeAll(); - memset(&Mock, 0, sizeof(Mock)); -} - -int get_power(fwk_id_t domain_id, uint32_t* power) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_power); - cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_power_CallInstance); - Mock.get_power_CallInstance = CMock_Guts_MemNext(Mock.get_power_CallInstance); - if (Mock.get_power_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.get_power_FinalReturn; - Mock.get_power_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.get_power_CallbackBool && - Mock.get_power_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.get_power_CallbackFunctionPointer(domain_id, power, Mock.get_power_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_domain_id) - { - UNITY_SET_DETAILS(CMockString_get_power,CMockString_domain_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_power) - { - UNITY_SET_DETAILS(CMockString_get_power,CMockString_power); - if (cmock_call_instance->Expected_power == NULL) - { UNITY_TEST_ASSERT_NULL(power, cmock_line, CMockStringExpNULL); } - else - { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power, power, cmock_call_instance->Expected_power_Depth, cmock_line, CMockStringMismatch); } - } - } - if (Mock.get_power_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.get_power_CallbackFunctionPointer(domain_id, power, Mock.get_power_CallbackCalls++); - } - if (cmock_call_instance->ReturnThruPtr_power_Used) - { - UNITY_TEST_ASSERT_NOT_NULL(power, cmock_line, CMockStringPtrIsNULL); - memcpy((void*)power, (void*)cmock_call_instance->ReturnThruPtr_power_Val, - cmock_call_instance->ReturnThruPtr_power_Size); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_get_power(CMOCK_get_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* power, int power_Depth); -void CMockExpectParameters_get_power(CMOCK_get_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* power, int power_Depth) -{ - memcpy((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), - sizeof(fwk_id_t[sizeof(domain_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_domain_id = 0; - cmock_call_instance->Expected_power = power; - cmock_call_instance->Expected_power_Depth = power_Depth; - cmock_call_instance->IgnoreArg_power = 0; - cmock_call_instance->ReturnThruPtr_power_Used = 0; -} - -void get_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_power_IgnoreBool = (char)1; -} - -void get_power_CMockStopIgnore(void) -{ - if(Mock.get_power_IgnoreBool) - Mock.get_power_CallInstance = CMock_Guts_MemNext(Mock.get_power_CallInstance); - Mock.get_power_IgnoreBool = (char)0; -} - -void get_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void get_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_power(cmock_call_instance, domain_id, power, 1); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_power_AddCallback(CMOCK_get_power_CALLBACK Callback) -{ - Mock.get_power_IgnoreBool = (char)0; - Mock.get_power_CallbackBool = (char)1; - Mock.get_power_CallbackFunctionPointer = Callback; -} - -void get_power_Stub(CMOCK_get_power_CALLBACK Callback) -{ - Mock.get_power_IgnoreBool = (char)0; - Mock.get_power_CallbackBool = (char)0; - Mock.get_power_CallbackFunctionPointer = Callback; -} - -void get_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int power_Depth, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_power(cmock_call_instance, domain_id, power, power_Depth); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size) -{ - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); - cmock_call_instance->ReturnThruPtr_power_Used = 1; - cmock_call_instance->ReturnThruPtr_power_Val = power; - cmock_call_instance->ReturnThruPtr_power_Size = cmock_size; -} - -void get_power_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_domain_id = 1; -} - -void get_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_power = 1; -} - -int set_power_change_notif_thresholds(fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_set_power_change_notif_thresholds); - cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_power_change_notif_thresholds_CallInstance); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemNext(Mock.set_power_change_notif_thresholds_CallInstance); - if (Mock.set_power_change_notif_thresholds_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.set_power_change_notif_thresholds_FinalReturn; - Mock.set_power_change_notif_thresholds_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.set_power_change_notif_thresholds_CallbackBool && - Mock.set_power_change_notif_thresholds_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.set_power_change_notif_thresholds_CallbackFunctionPointer(id, threshold_low, threshold_high, Mock.set_power_change_notif_thresholds_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_id) - { - UNITY_SET_DETAILS(CMockString_set_power_change_notif_thresholds,CMockString_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_threshold_low) - { - UNITY_SET_DETAILS(CMockString_set_power_change_notif_thresholds,CMockString_threshold_low); - UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_threshold_low, threshold_low, cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_threshold_high) - { - UNITY_SET_DETAILS(CMockString_set_power_change_notif_thresholds,CMockString_threshold_high); - UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_threshold_high, threshold_high, cmock_line, CMockStringMismatch); - } - } - if (Mock.set_power_change_notif_thresholds_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.set_power_change_notif_thresholds_CallbackFunctionPointer(id, threshold_low, threshold_high, Mock.set_power_change_notif_thresholds_CallbackCalls++); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_set_power_change_notif_thresholds(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high); -void CMockExpectParameters_set_power_change_notif_thresholds(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high) -{ - memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), - sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_id = 0; - cmock_call_instance->Expected_threshold_low = threshold_low; - cmock_call_instance->IgnoreArg_threshold_low = 0; - cmock_call_instance->Expected_threshold_high = threshold_high; - cmock_call_instance->IgnoreArg_threshold_high = 0; -} - -void set_power_change_notif_thresholds_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE)); - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemChain(Mock.set_power_change_notif_thresholds_CallInstance, cmock_guts_index); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)1; -} - -void set_power_change_notif_thresholds_CMockStopIgnore(void) -{ - if(Mock.set_power_change_notif_thresholds_IgnoreBool) - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemNext(Mock.set_power_change_notif_thresholds_CallInstance); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; -} - -void set_power_change_notif_thresholds_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE)); - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemChain(Mock.set_power_change_notif_thresholds_CallInstance, cmock_guts_index); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void set_power_change_notif_thresholds_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE)); - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemChain(Mock.set_power_change_notif_thresholds_CallInstance, cmock_guts_index); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_set_power_change_notif_thresholds(cmock_call_instance, id, threshold_low, threshold_high); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void set_power_change_notif_thresholds_AddCallback(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback) -{ - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - Mock.set_power_change_notif_thresholds_CallbackBool = (char)1; - Mock.set_power_change_notif_thresholds_CallbackFunctionPointer = Callback; -} - -void set_power_change_notif_thresholds_Stub(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback) -{ - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - Mock.set_power_change_notif_thresholds_CallbackBool = (char)0; - Mock.set_power_change_notif_thresholds_CallbackFunctionPointer = Callback; -} - -void set_power_change_notif_thresholds_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_change_notif_thresholds_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_id = 1; -} - -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_low(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_change_notif_thresholds_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_threshold_low = 1; -} - -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_high(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_change_notif_thresholds_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_threshold_high = 1; -} - diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h b/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h deleted file mode 100644 index e9bd95214d9f2acdf4661f3a7e9e79be42d94cad..0000000000000000000000000000000000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h +++ /dev/null @@ -1,74 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#ifndef _MOCKMOD_POWER_METER_EXTRA_H -#define _MOCKMOD_POWER_METER_EXTRA_H - -#include "unity.h" -#include "mod_power_meter_extra.h" - -/* Ignore the following warnings, since we are copying code */ -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic push -#endif -#if !defined(__clang__) -#pragma GCC diagnostic ignored "-Wpragmas" -#endif -#pragma GCC diagnostic ignored "-Wunknown-pragmas" -#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" -#endif - -void Mockmod_power_meter_extra_Init(void); -void Mockmod_power_meter_extra_Destroy(void); -void Mockmod_power_meter_extra_Verify(void); - - - - -#define get_power_IgnoreAndReturn(cmock_retval) get_power_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_power_StopIgnore() get_power_CMockStopIgnore() -void get_power_CMockStopIgnore(void); -#define get_power_ExpectAnyArgsAndReturn(cmock_retval) get_power_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_power_ExpectAndReturn(domain_id, power, cmock_retval) get_power_CMockExpectAndReturn(__LINE__, domain_id, power, cmock_retval) -void get_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int cmock_to_return); -typedef int (* CMOCK_get_power_CALLBACK)(fwk_id_t domain_id, uint32_t* power, int cmock_num_calls); -void get_power_AddCallback(CMOCK_get_power_CALLBACK Callback); -void get_power_Stub(CMOCK_get_power_CALLBACK Callback); -#define get_power_StubWithCallback get_power_Stub -#define get_power_ExpectWithArrayAndReturn(domain_id, power, power_Depth, cmock_retval) get_power_CMockExpectWithArrayAndReturn(__LINE__, domain_id, power, power_Depth, cmock_retval) -void get_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int power_Depth, int cmock_to_return); -#define get_power_ReturnThruPtr_power(power) get_power_CMockReturnMemThruPtr_power(__LINE__, power, sizeof(uint32_t)) -#define get_power_ReturnArrayThruPtr_power(power, cmock_len) get_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_len * sizeof(*power)) -#define get_power_ReturnMemThruPtr_power(power, cmock_size) get_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_size) -void get_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size); -#define get_power_IgnoreArg_domain_id() get_power_CMockIgnoreArg_domain_id(__LINE__) -void get_power_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); -#define get_power_IgnoreArg_power() get_power_CMockIgnoreArg_power(__LINE__) -void get_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line); -#define set_power_change_notif_thresholds_IgnoreAndReturn(cmock_retval) set_power_change_notif_thresholds_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void set_power_change_notif_thresholds_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_power_change_notif_thresholds_StopIgnore() set_power_change_notif_thresholds_CMockStopIgnore() -void set_power_change_notif_thresholds_CMockStopIgnore(void); -#define set_power_change_notif_thresholds_ExpectAnyArgsAndReturn(cmock_retval) set_power_change_notif_thresholds_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void set_power_change_notif_thresholds_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_power_change_notif_thresholds_ExpectAndReturn(id, threshold_low, threshold_high, cmock_retval) set_power_change_notif_thresholds_CMockExpectAndReturn(__LINE__, id, threshold_low, threshold_high, cmock_retval) -void set_power_change_notif_thresholds_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high, int cmock_to_return); -typedef int (* CMOCK_set_power_change_notif_thresholds_CALLBACK)(fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high, int cmock_num_calls); -void set_power_change_notif_thresholds_AddCallback(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback); -void set_power_change_notif_thresholds_Stub(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback); -#define set_power_change_notif_thresholds_StubWithCallback set_power_change_notif_thresholds_Stub -#define set_power_change_notif_thresholds_IgnoreArg_id() set_power_change_notif_thresholds_CMockIgnoreArg_id(__LINE__) -void set_power_change_notif_thresholds_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); -#define set_power_change_notif_thresholds_IgnoreArg_threshold_low() set_power_change_notif_thresholds_CMockIgnoreArg_threshold_low(__LINE__) -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_low(UNITY_LINE_TYPE cmock_line); -#define set_power_change_notif_thresholds_IgnoreArg_threshold_high() set_power_change_notif_thresholds_CMockIgnoreArg_threshold_high(__LINE__) -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_high(UNITY_LINE_TYPE cmock_line); - -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic pop -#endif -#endif - -#endif diff --git a/module/scmi_power_capping/test/mod_power_capping_extra.h b/module/scmi_power_capping/test/mod_power_capping_extra.h index 35e482272109ed423802a3f7bc1654a4581dc648..85e38262cac3c52f782cf9d7c4e1ff2e29102312 100644 --- a/module/scmi_power_capping/test/mod_power_capping_extra.h +++ b/module/scmi_power_capping/test/mod_power_capping_extra.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -13,4 +13,12 @@ int get_applied_cap(fwk_id_t domain_id, uint32_t *cap); int request_cap(fwk_id_t domain_id, uint32_t cap); +int get_average_power(fwk_id_t id, uint32_t *power); +int set_averaging_interval(fwk_id_t id, uint32_t pai); +int get_averaging_interval(fwk_id_t id, uint32_t *pai); +int get_averaging_interval_step(fwk_id_t id, uint32_t *pai_step); +int get_averaging_interval_range( + fwk_id_t id, + uint32_t *min_pai, + uint32_t *max_pai); #endif /* MOD_POWER_CAPPING_EXTRA_H_ */ diff --git a/module/scmi_power_capping/test/mod_power_coordinator_extra.h b/module/scmi_power_capping/test/mod_power_coordinator_extra.h deleted file mode 100644 index ed9259ae0d7a25c4d311fff4c7ee10cfe3f955b6..0000000000000000000000000000000000000000 --- a/module/scmi_power_capping/test/mod_power_coordinator_extra.h +++ /dev/null @@ -1,15 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#ifndef MOD_POWER_COORIDNATOR_EXTRA_H_ -# define MOD_POWER_COORDINATOR_EXTRA_H_ - -# include "mod_power_coordinator.h" - -int get_coordinator_period(fwk_id_t domain_id, uint32_t *period); -int set_coordinator_period(fwk_id_t domain_id, uint32_t period); -#endif /* MOD_POWER_COORDINATOR_EXTRA_H_ */ diff --git a/module/scmi_power_capping/test/mod_power_meter_extra.h b/module/scmi_power_capping/test/mod_power_meter_extra.h deleted file mode 100644 index d565b8d2cff62801d96903c75378407b9de95931..0000000000000000000000000000000000000000 --- a/module/scmi_power_capping/test/mod_power_meter_extra.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#ifndef MOD_POWER_METER_EXTRA_H_ -#define MOD_POWER_METER_EXTRA_H_ - -#include "mod_power_meter.h" - -int get_power(fwk_id_t domain_id, uint32_t *power); - -int set_power_change_notif_thresholds( - fwk_id_t id, - uint32_t threshold_low, - uint32_t threshold_high); -#endif /* MOD_POWER_METER_EXTRA_H_ */ diff --git a/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c b/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c index 2164f148e71acb4b56194e089a1664f7f7fec632..7692f95ef9069fce24feb79128a4d3d32ae519fa 100644 --- a/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c +++ b/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -125,21 +125,6 @@ void utest_scmi_power_capping_bind_success(void) &(power_management_apis.power_capping_api), FWK_SUCCESS); - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), - FWK_ID_API( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_API_IDX_PERIOD), - &(power_management_apis.power_coordinator_api), - FWK_SUCCESS); - - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), - FWK_ID_API( - FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT), - &(power_management_apis.power_meter_api), - FWK_SUCCESS); - #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS pcapping_protocol_bind_ExpectAndReturn(FWK_SUCCESS); pcapping_protocol_set_power_apis_Expect(&power_management_apis); @@ -166,21 +151,6 @@ void utest_scmi_power_capping_bind_failure(void) &(power_management_apis.power_capping_api), FWK_SUCCESS); - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), - FWK_ID_API( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_API_IDX_PERIOD), - &(power_management_apis.power_coordinator_api), - FWK_SUCCESS); - - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), - FWK_ID_API( - FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT), - &(power_management_apis.power_meter_api), - FWK_SUCCESS); - #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS pcapping_protocol_bind_ExpectAndReturn(FWK_E_INIT); #endif diff --git a/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c b/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c index 3ba5d51cad6888dee0c6aeb7a0e4657ac0d4cee9..529d94fb216d9bdfc6a72f11d43a4cbc830c8ad0 100644 --- a/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c +++ b/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -11,7 +11,6 @@ #include #include #include -#include #include #include @@ -87,16 +86,15 @@ static const struct mod_transport_fast_channels_api transport_fch_api = { static const struct mod_power_capping_api power_capping_api = { .get_applied_cap = get_applied_cap, .request_cap = request_cap, -}; - -static const struct mod_power_coordinator_api power_coordinator_api = { - .get_coordinator_period = get_coordinator_period, - .set_coordinator_period = set_coordinator_period, + .get_average_power = get_average_power, + .get_averaging_interval = get_averaging_interval, + .get_averaging_interval_range = get_averaging_interval_range, + .get_averaging_interval_step = get_averaging_interval_step, + .set_averaging_interval = set_averaging_interval, }; static const struct mod_scmi_power_capping_power_apis power_management_apis = { .power_capping_api = &power_capping_api, - .power_coordinator_api = &power_coordinator_api, }; static uint32_t local_fast_channel_memory_emulation; @@ -205,13 +203,12 @@ void utest_pcapping_fast_channel_process_command_pai_get(void) (FAKE_POWER_CAPPING_IDX_1 * MOD_SCMI_PCAPPING_FAST_CHANNEL_COUNT) + MOD_SCMI_PCAPPING_FAST_CHANNEL_PAI_GET; - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); pcapping_fast_channel_process_command(fch_idx); TEST_ASSERT_EQUAL(local_fast_channel_memory_emulation, pai); @@ -227,10 +224,11 @@ void utest_pcapping_fast_channel_process_command_pai_set(void) local_fast_channel_memory_emulation = __LINE__; - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, local_fast_channel_memory_emulation, FWK_SUCCESS); + pcapping_fast_channel_process_command(fch_idx); } @@ -287,16 +285,15 @@ void utest_pcapping_fast_channel_process_event_timer_interrupt(void) FWK_SUCCESS); break; case MOD_SCMI_PCAPPING_FAST_CHANNEL_PAI_GET: - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, NULL, - 0, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); + get_averaging_interval_IgnoreArg_pai(); break; case MOD_SCMI_PCAPPING_FAST_CHANNEL_PAI_SET: - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, local_fast_channel_memory_emulation, FWK_SUCCESS); break; diff --git a/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c b/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c index 40509bf9ee258299309298cf89b91d71cb5fc917..3b146265893b66000e5d0393820d1031dce7510c 100644 --- a/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c +++ b/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -14,8 +14,6 @@ #include #include #include -#include -#include #include #include #include @@ -88,15 +86,11 @@ static const struct mod_scmi_from_protocol_api scmi_api = { static const struct mod_power_capping_api power_capping_api = { .get_applied_cap = get_applied_cap, .request_cap = request_cap, -}; - -static const struct mod_power_coordinator_api power_coordinator_api = { - .get_coordinator_period = get_coordinator_period, - .set_coordinator_period = set_coordinator_period, -}; - -static const struct mod_power_meter_api power_meter_api = { - .get_power = get_power, + .get_average_power = get_average_power, + .get_averaging_interval = get_averaging_interval, + .get_averaging_interval_range = get_averaging_interval_range, + .get_averaging_interval_step = get_averaging_interval_step, + .set_averaging_interval = set_averaging_interval, }; #ifdef BUILD_HAS_MOD_RESOURCE_PERMS @@ -117,8 +111,6 @@ static const struct mod_scmi_notification_api scmi_notification_api = { static const struct mod_scmi_power_capping_power_apis power_management_apis = { .power_capping_api = &power_capping_api, - .power_coordinator_api = &power_coordinator_api, - .power_meter_api = &power_meter_api, }; static fwk_id_t service_id_1 = @@ -134,12 +126,10 @@ static const struct mod_scmi_power_capping_domain_config #ifdef BUILD_HAS_SCMI_NOTIFICATIONS .cap_pai_change_notification_support = true, #endif - .min_pai = MIN_DEFAULT_PAI, - .max_pai = MAX_DEFAULT_PAI, - .pai_step = 1, .min_power_cap = MIN_DEFAULT_POWER_CAP, .max_power_cap = MAX_DEFAULT_POWER_CAP, .power_cap_step = 1, + .pai_config_support = true, }; static const struct mod_scmi_power_capping_domain_config @@ -149,6 +139,7 @@ static const struct mod_scmi_power_capping_domain_config FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_CAPPING, __LINE__), .min_power_cap = MIN_DEFAULT_POWER_CAP, .max_power_cap = MIN_DEFAULT_POWER_CAP, + .pai_config_support = true, }; static struct mod_scmi_power_capping_domain_context @@ -185,12 +176,6 @@ static void test_request_cap_config_supported( domain_ctx_table[domain_idx].cap_config_support = cap_config_supported; } -static void test_set_pai_config_supported( - unsigned int domain_idx, - bool pai_config_supported) -{ - domain_ctx_table[domain_idx].pai_config_support = pai_config_supported; -} /* Test functions */ /* Initialize the tests */ static void test_init(void) @@ -230,8 +215,6 @@ void tearDown(void) { Mockmod_power_capping_extra_Verify(); Mockmod_scmi_extra_Verify(); - Mockmod_power_coordinator_extra_Verify(); - Mockmod_power_meter_extra_Verify(); Mockfwk_id_Verify(); #ifdef BUILD_HAS_MOD_RESOURCE_PERMS Mockmod_resource_perms_extra_Verify(); @@ -391,6 +374,10 @@ void utest_message_handler_domain_invalid(void) void utest_message_handler_domain_attributes_valid(void) { + uint32_t min_pai = MIN_DEFAULT_PAI; + uint32_t max_pai = MAX_DEFAULT_PAI; + uint32_t pai_step = 1; + struct mod_scmi_power_capping_domain_context *domain_ctx = &domain_ctx_table[FAKE_POWER_CAPPING_IDX_1]; const struct mod_scmi_power_capping_domain_config *config = @@ -404,12 +391,12 @@ void utest_message_handler_domain_attributes_valid(void) struct scmi_power_capping_domain_attributes_p2a ret_payload = { .status = SCMI_SUCCESS, - .attributes = 1u << POWER_CAP_CONF_SUP_POS | + .attributes = 1u << POWER_CAP_CONF_SUP_POS | 1u << PAI_CONF_SUP_POS | config->power_cap_unit << POWER_UNIT_POS, .name = "TestPowerCap", - .min_pai = config->min_pai, - .max_pai = config->max_pai, - .pai_step = config->pai_step, + .min_pai = min_pai, + .max_pai = max_pai, + .pai_step = pai_step, .min_power_cap = config->min_power_cap, .max_power_cap = config->max_power_cap, .power_cap_step = config->power_cap_step, @@ -417,6 +404,22 @@ void utest_message_handler_domain_attributes_valid(void) .parent_id = config->parent_idx, }; + uint32_t expected_pai_step = pai_step; + uint32_t expected_min_pai = min_pai; + uint32_t expected_max_pai = max_pai; + + get_averaging_interval_step_ExpectAndReturn( + config->power_capping_domain_id, NULL, FWK_SUCCESS); + get_averaging_interval_step_IgnoreArg_pai_step(); + get_averaging_interval_step_ReturnThruPtr_pai_step(&expected_pai_step); + + get_averaging_interval_range_ExpectAndReturn( + config->power_capping_domain_id, NULL, NULL, FWK_SUCCESS); + get_averaging_interval_range_IgnoreArg_min_pai(); + get_averaging_interval_range_IgnoreArg_max_pai(); + get_averaging_interval_range_ReturnThruPtr_min_pai(&expected_min_pai); + get_averaging_interval_range_ReturnThruPtr_max_pai(&expected_max_pai); + #ifdef BUILD_HAS_SCMI_NOTIFICATIONS ret_payload.attributes |= config->cap_pai_change_notification_support << POWER_CAPPING_NOTIF_SUP_POS; @@ -726,13 +729,12 @@ void utest_message_handler_power_capping_get_pai_valid(void) .pai = pai, }; - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -742,8 +744,6 @@ void utest_message_handler_power_capping_get_pai_valid(void) void utest_message_handler_power_capping_get_pai_failure(void) { - uint32_t pai = __LINE__; /* Arbitrary value */ - struct scmi_power_capping_pai_get_a2p cmd_payload = { .domain_id = FAKE_POWER_CAPPING_IDX_1 }; @@ -752,12 +752,11 @@ void utest_message_handler_power_capping_get_pai_failure(void) .status = SCMI_GENERIC_ERROR, }; - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_E_DEVICE); - get_coordinator_period_IgnoreArg_period(); + get_averaging_interval_IgnoreArg_pai(); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -778,14 +777,12 @@ void utest_message_handler_power_capping_set_pai_valid(void) .status = SCMI_SUCCESS, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); - #ifdef BUILD_HAS_SCMI_NOTIFICATIONS fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); #endif - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, pai, FWK_SUCCESS); @@ -808,14 +805,12 @@ void utest_message_handler_power_capping_set_pai_failure(void) .status = SCMI_GENERIC_ERROR, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); - #ifdef BUILD_HAS_SCMI_NOTIFICATIONS fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); #endif - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, pai, FWK_E_DEVICE); @@ -837,7 +832,14 @@ void utest_message_handler_power_capping_set_less_than_min_pai(void) .status = SCMI_OUT_OF_RANGE, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); +#endif + + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + pai, + FWK_E_RANGE); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -857,7 +859,15 @@ void utest_message_handler_power_capping_set_more_than_max_pai(void) .status = SCMI_OUT_OF_RANGE, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); +#endif + + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + pai, + FWK_E_RANGE); + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); EXPECT_RESPONSE_ERROR(ret_payload); @@ -879,21 +889,19 @@ void utest_message_handler_power_capping_get_power_measurement_valid(void) .pai = pai, }; - get_power_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_meter_domain_id, - &power, - sizeof(power), + get_average_power_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_power_IgnoreArg_power(); - get_power_ReturnMemThruPtr_power(&power, sizeof(power)); + get_average_power_IgnoreArg_power(); + get_average_power_ReturnThruPtr_power(&power); - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -903,8 +911,6 @@ void utest_message_handler_power_capping_get_power_measurement_valid(void) void utest_message_handler_power_capping_get_power_measurement_failure(void) { - uint32_t power = __LINE__; /* Arbitrary value */ - struct scmi_power_capping_measurements_get_a2p cmd_payload = { .domain_id = FAKE_POWER_CAPPING_IDX_1, }; @@ -913,12 +919,11 @@ void utest_message_handler_power_capping_get_power_measurement_failure(void) .status = SCMI_GENERIC_ERROR, }; - get_power_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_meter_domain_id, - &power, - sizeof(power), + get_average_power_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_E_DEVICE); - get_power_IgnoreArg_power(); + get_average_power_IgnoreArg_power(); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -1074,13 +1079,13 @@ void utest_pcapping_protocol_process_cap_pai_notify_event_success(void) get_applied_cap_IgnoreArg_cap(); get_applied_cap_ReturnMemThruPtr_cap(&cap, sizeof(cap)); - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + get_averaging_interval_ExpectWithArrayAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, &pai, sizeof(pai), FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); scmi_notification_notify_ExpectWithArrayAndReturn( MOD_SCMI_PROTOCOL_ID_POWER_CAPPING, @@ -1120,13 +1125,12 @@ void utest_pcapping_protocol_process_measurements_notify_event_success(void) *event_params_ptr = event_params; - get_power_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_meter_domain_id, - &power, - sizeof(power), + get_average_power_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_power_IgnoreArg_power(); - get_power_ReturnMemThruPtr_power(&power, sizeof(power)); + get_average_power_IgnoreArg_power(); + get_average_power_ReturnThruPtr_power(&power); scmi_notification_notify_ExpectWithArrayAndReturn( MOD_SCMI_PROTOCOL_ID_POWER_CAPPING, @@ -1313,17 +1317,17 @@ void utest_pcapping_protocol_start_element(void) fwk_notification_subscribe_ExpectAndReturn( FWK_ID_NOTIFICATION( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_PERIOD_CHANGED), - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_PAI_CHANGED), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), element_id, FWK_SUCCESS); fwk_notification_subscribe_ExpectAndReturn( FWK_ID_NOTIFICATION( - FWK_MODULE_IDX_POWER_METER, - MOD_POWER_METER_NOTIFICATION_IDX_MEASUREMENTS_CHANGED), - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_MEASUREMENTS_CHANGED), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), element_id, FWK_SUCCESS);