From 53644dc4146e8df8ce9ac8aa3b1479dee5c08327 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Tue, 12 Nov 2024 15:56:10 +0000 Subject: [PATCH 1/8] interface/power_management: Include `power` in API's names Rename APIs to include power term to avoid confusion. Update callers and interface mocks with the new name. Signed-off-by: Mohamed Omar Asaker --- .../interface_power_management.h | 4 +- .../metrics_analyzer/doc/metrics_analyzer.md | 10 +- .../src/mod_metrics_analyzer.c | 6 +- .../test/config_metrics_analyzer.h | 5 +- .../mocks/Mockmod_metrics_analyzer_extra.c | 268 +++++++++--------- .../mocks/Mockmod_metrics_analyzer_extra.h | 76 ++--- .../test/mod_metrics_analyzer_extra.h | 4 +- .../test/mod_metrics_analyzer_unit_test.c | 40 +-- module/mpmm_v2/src/mod_mpmm_v2.c | 6 +- module/mpmm_v2/test/mod_mpmm_v2_unit_test.c | 24 +- .../perf_controller/src/mod_perf_controller.c | 6 +- .../test/mod_perf_controller_unit_test.c | 6 +- module/power_capping/src/mod_power_capping.c | 8 +- .../test/mocks/Mockmod_power_capping_extra.c | 142 +++++----- .../test/mocks/Mockmod_power_capping_extra.h | 44 +-- .../test/mod_power_capping_extra.h | 2 +- .../test/mod_power_capping_unit_test.c | 20 +- .../src/mod_thermal_power_estimator.c | 4 +- 18 files changed, 341 insertions(+), 334 deletions(-) diff --git a/interface/power_management/interface_power_management.h b/interface/power_management/interface_power_management.h index f14418131..cdea316f2 100644 --- a/interface/power_management/interface_power_management.h +++ b/interface/power_management/interface_power_management.h @@ -58,7 +58,7 @@ struct interface_power_management_api { * - The `power_limit` parameter is a null pointer. * \retval ::FWK_E_BUSY Limit for the requested id is not ready yet. */ - int (*get_limit)(fwk_id_t id, uint32_t *power_limit); + int (*get_power_limit)(fwk_id_t id, uint32_t *power_limit); /*! * \brief Set the power limit for an entity to be registered. This doesn't * necessarily mean the power limit is set physically. @@ -68,7 +68,7 @@ struct interface_power_management_api { * \retval ::FWK_SUCCESS The power limit is set successfully * \retval One of the standard framework status codes. */ - int (*set_limit)(fwk_id_t id, uint32_t power_limit); + int (*set_power_limit)(fwk_id_t id, uint32_t power_limit); }; /*! diff --git a/module/metrics_analyzer/doc/metrics_analyzer.md b/module/metrics_analyzer/doc/metrics_analyzer.md index 1c63ddcf9..9316c15c6 100644 --- a/module/metrics_analyzer/doc/metrics_analyzer.md +++ b/module/metrics_analyzer/doc/metrics_analyzer.md @@ -19,7 +19,7 @@ The system domains are bound by the lowest power limit metric. This module **consumes** `power limits` from multiple providers. -Limits providers must implement `get_limit` API which returns the power_limit +Limits providers must implement `get_power_limit` API which returns the power_limit for the givin domain. The following diagram shows the data flow for each domain (domain view) @@ -58,19 +58,19 @@ sequenceDiagram Coordinator->>Metrics_Analyzer: analyze() loop for each domain Metrics_Analyzer->>Metrics_Analyzer: Set aggregate limit to max - Metrics_Analyzer->>Provider_0: get_limit(domain_id, &power_limit) + Metrics_Analyzer->>Provider_0: get_power_limit(domain_id, &power_limit) Provider_0--)Metrics_Analyzer: status Metrics_Analyzer->>Metrics_Analyzer: Update aggregate limit - Metrics_Analyzer->>Provider_1: get_limit(domain_id, &power_limit) + Metrics_Analyzer->>Provider_1: get_power_limit(domain_id, &power_limit) Provider_1--)Metrics_Analyzer: status Metrics_Analyzer->>Metrics_Analyzer: Update aggregate limit - Metrics_Analyzer->>Provider_m: get_limit(domain_id, &power_limit) + Metrics_Analyzer->>Provider_m: get_power_limit(domain_id, &power_limit) Provider_m--)Metrics_Analyzer: status Metrics_Analyzer->>Metrics_Analyzer: Update aggregate limit opt if evaluation is necessary Metrics_Analyzer->>Metrics_Analyzer: evaluate_minimum(domain_id) end - Metrics_Analyzer->>Consumer: set_limit(domain_id, power_limit) + Metrics_Analyzer->>Consumer: set_power_limit(domain_id, power_limit) Consumer--)Metrics_Analyzer: status end Metrics_Analyzer--)Coordinator: status diff --git a/module/metrics_analyzer/src/mod_metrics_analyzer.c b/module/metrics_analyzer/src/mod_metrics_analyzer.c index 5e073ffda..ec3e16be2 100644 --- a/module/metrics_analyzer/src/mod_metrics_analyzer.c +++ b/module/metrics_analyzer/src/mod_metrics_analyzer.c @@ -53,7 +53,7 @@ static int collect_domain_limits(struct mod_domain_ctx *domain_ctx) for (size_t i = 0; i < domain_ctx->metrics_count; ++i) { uint32_t power_limit; struct mod_metric_ctx *metric_ctx = &domain_ctx->metrics[i]; - status = metric_ctx->limit_provider_api->get_limit( + status = metric_ctx->limit_provider_api->get_power_limit( metric_ctx->limit_provider_config->domain_id, &power_limit); if (status == FWK_SUCCESS) { metric_ctx->limit = power_limit; @@ -73,11 +73,11 @@ static int report_domain_aggregate_limit(struct mod_domain_ctx *domain_ctx) return FWK_E_PARAM; } if (domain_ctx->limit_consumer_api == NULL || - domain_ctx->limit_consumer_api->set_limit == NULL) { + domain_ctx->limit_consumer_api->set_power_limit == NULL) { return FWK_E_PANIC; } - return domain_ctx->limit_consumer_api->set_limit( + return domain_ctx->limit_consumer_api->set_power_limit( domain_ctx->config->limit_consumer.domain_id, domain_ctx->aggregate_limit); } diff --git a/module/metrics_analyzer/test/config_metrics_analyzer.h b/module/metrics_analyzer/test/config_metrics_analyzer.h index 304d7a75a..7a863a220 100644 --- a/module/metrics_analyzer/test/config_metrics_analyzer.h +++ b/module/metrics_analyzer/test/config_metrics_analyzer.h @@ -64,10 +64,11 @@ enum metric_idx { #define ID(module, domain) \ FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_##module, module##_DOMAIN_IDX_##domain) -/* Assume that all providers has their get_limit API index equal to zero */ +/* Assume that all providers has their get_power_limit API index equal to zero + */ #define PROVIDER_API_ID(module) FWK_ID_API_INIT(FWK_MODULE_IDX_##module, 0) -/* Assume that the consumer has set_limit API index equal to zero */ +/* Assume that the consumer has set_power_limit API index equal to zero */ #define CONSUMER_API_ID FWK_ID_API_INIT(FWK_MODULE_IDX_CONSUMER, 0) #define PROVIDER_ENTRY(name, domain) \ diff --git a/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.c b/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.c index 6005db924..3d3a2ddd6 100644 --- a/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.c +++ b/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.c @@ -5,12 +5,12 @@ #include "cmock.h" #include "Mockmod_metrics_analyzer_extra.h" -static const char* CMockString_get_limit = "get_limit"; +static const char* CMockString_get_power_limit = "get_power_limit"; static const char* CMockString_id = "id"; static const char* CMockString_power_limit = "power_limit"; -static const char* CMockString_set_limit = "set_limit"; +static const char* CMockString_set_power_limit = "set_power_limit"; -typedef struct _CMOCK_get_limit_CALL_INSTANCE +typedef struct _CMOCK_get_power_limit_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; @@ -24,9 +24,9 @@ typedef struct _CMOCK_get_limit_CALL_INSTANCE char IgnoreArg_id; char IgnoreArg_power_limit; -} CMOCK_get_limit_CALL_INSTANCE; +} CMOCK_get_power_limit_CALL_INSTANCE; -typedef struct _CMOCK_set_limit_CALL_INSTANCE +typedef struct _CMOCK_set_power_limit_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; @@ -36,22 +36,22 @@ typedef struct _CMOCK_set_limit_CALL_INSTANCE char IgnoreArg_id; char IgnoreArg_power_limit; -} CMOCK_set_limit_CALL_INSTANCE; +} CMOCK_set_power_limit_CALL_INSTANCE; static struct Mockmod_metrics_analyzer_extraInstance { - char get_limit_IgnoreBool; - int get_limit_FinalReturn; - char get_limit_CallbackBool; - CMOCK_get_limit_CALLBACK get_limit_CallbackFunctionPointer; - int get_limit_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_limit_CallInstance; - char set_limit_IgnoreBool; - int set_limit_FinalReturn; - char set_limit_CallbackBool; - CMOCK_set_limit_CALLBACK set_limit_CallbackFunctionPointer; - int set_limit_CallbackCalls; - CMOCK_MEM_INDEX_TYPE set_limit_CallInstance; + char get_power_limit_IgnoreBool; + int get_power_limit_FinalReturn; + char get_power_limit_CallbackBool; + CMOCK_get_power_limit_CALLBACK get_power_limit_CallbackFunctionPointer; + int get_power_limit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_power_limit_CallInstance; + char set_power_limit_IgnoreBool; + int set_power_limit_FinalReturn; + char set_power_limit_CallbackBool; + CMOCK_set_power_limit_CALLBACK set_power_limit_CallbackFunctionPointer; + int set_power_limit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE set_power_limit_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -60,28 +60,28 @@ void Mockmod_metrics_analyzer_extra_Verify(void) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_MEM_INDEX_TYPE call_instance; - call_instance = Mock.get_limit_CallInstance; - if (Mock.get_limit_IgnoreBool) + call_instance = Mock.get_power_limit_CallInstance; + if (Mock.get_power_limit_IgnoreBool) call_instance = CMOCK_GUTS_NONE; if (CMOCK_GUTS_NONE != call_instance) { - UNITY_SET_DETAIL(CMockString_get_limit); + UNITY_SET_DETAIL(CMockString_get_power_limit); UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } - if (Mock.get_limit_CallbackFunctionPointer != NULL) + if (Mock.get_power_limit_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; } - call_instance = Mock.set_limit_CallInstance; - if (Mock.set_limit_IgnoreBool) + call_instance = Mock.set_power_limit_CallInstance; + if (Mock.set_power_limit_IgnoreBool) call_instance = CMOCK_GUTS_NONE; if (CMOCK_GUTS_NONE != call_instance) { - UNITY_SET_DETAIL(CMockString_set_limit); + UNITY_SET_DETAIL(CMockString_set_power_limit); UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } - if (Mock.set_limit_CallbackFunctionPointer != NULL) + if (Mock.set_power_limit_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; @@ -99,25 +99,25 @@ void Mockmod_metrics_analyzer_extra_Destroy(void) memset(&Mock, 0, sizeof(Mock)); } -int get_limit(fwk_id_t id, uint32_t* power_limit) +int get_power_limit(fwk_id_t id, uint32_t* power_limit) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_limit); - cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_limit_CallInstance); - Mock.get_limit_CallInstance = CMock_Guts_MemNext(Mock.get_limit_CallInstance); - if (Mock.get_limit_IgnoreBool) + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_power_limit); + cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_power_limit_CallInstance); + Mock.get_power_limit_CallInstance = CMock_Guts_MemNext(Mock.get_power_limit_CallInstance); + if (Mock.get_power_limit_IgnoreBool) { UNITY_CLR_DETAILS(); if (cmock_call_instance == NULL) - return Mock.get_limit_FinalReturn; - Mock.get_limit_FinalReturn = cmock_call_instance->ReturnVal; + return Mock.get_power_limit_FinalReturn; + Mock.get_power_limit_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } - if (!Mock.get_limit_CallbackBool && - Mock.get_limit_CallbackFunctionPointer != NULL) + if (!Mock.get_power_limit_CallbackBool && + Mock.get_power_limit_CallbackFunctionPointer != NULL) { - int cmock_cb_ret = Mock.get_limit_CallbackFunctionPointer(id, power_limit, Mock.get_limit_CallbackCalls++); + int cmock_cb_ret = Mock.get_power_limit_CallbackFunctionPointer(id, power_limit, Mock.get_power_limit_CallbackCalls++); UNITY_CLR_DETAILS(); return cmock_cb_ret; } @@ -127,21 +127,21 @@ int get_limit(fwk_id_t id, uint32_t* power_limit) { if (!cmock_call_instance->IgnoreArg_id) { - UNITY_SET_DETAILS(CMockString_get_limit,CMockString_id); + UNITY_SET_DETAILS(CMockString_get_power_limit,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_limit) { - UNITY_SET_DETAILS(CMockString_get_limit,CMockString_power_limit); + UNITY_SET_DETAILS(CMockString_get_power_limit,CMockString_power_limit); if (cmock_call_instance->Expected_power_limit == NULL) { UNITY_TEST_ASSERT_NULL(power_limit, cmock_line, CMockStringExpNULL); } else { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power_limit, power_limit, cmock_call_instance->Expected_power_limit_Depth, cmock_line, CMockStringMismatch); } } } - if (Mock.get_limit_CallbackFunctionPointer != NULL) + if (Mock.get_power_limit_CallbackFunctionPointer != NULL) { - cmock_call_instance->ReturnVal = Mock.get_limit_CallbackFunctionPointer(id, power_limit, Mock.get_limit_CallbackCalls++); + cmock_call_instance->ReturnVal = Mock.get_power_limit_CallbackFunctionPointer(id, power_limit, Mock.get_power_limit_CallbackCalls++); } if (cmock_call_instance->ReturnThruPtr_power_limit_Used) { @@ -153,8 +153,8 @@ int get_limit(fwk_id_t id, uint32_t* power_limit) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth); -void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth) +void CMockExpectParameters_get_power_limit(CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth); +void CMockExpectParameters_get_power_limit(CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_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 */ @@ -165,125 +165,125 @@ void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_i cmock_call_instance->ReturnThruPtr_power_limit_Used = 0; } -void get_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_limit_IgnoreBool = (char)1; + Mock.get_power_limit_IgnoreBool = (char)1; } -void get_limit_CMockStopIgnore(void) +void get_power_limit_CMockStopIgnore(void) { - if(Mock.get_limit_IgnoreBool) - Mock.get_limit_CallInstance = CMock_Guts_MemNext(Mock.get_limit_CallInstance); - Mock.get_limit_IgnoreBool = (char)0; + if(Mock.get_power_limit_IgnoreBool) + Mock.get_power_limit_CallInstance = CMock_Guts_MemNext(Mock.get_power_limit_CallInstance); + Mock.get_power_limit_IgnoreBool = (char)0; } -void get_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_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_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return) +void get_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_limit(cmock_call_instance, id, power_limit, 1); + CMockExpectParameters_get_power_limit(cmock_call_instance, id, power_limit, 1); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_limit_AddCallback(CMOCK_get_limit_CALLBACK Callback) +void get_power_limit_AddCallback(CMOCK_get_power_limit_CALLBACK Callback) { - Mock.get_limit_IgnoreBool = (char)0; - Mock.get_limit_CallbackBool = (char)1; - Mock.get_limit_CallbackFunctionPointer = Callback; + Mock.get_power_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallbackBool = (char)1; + Mock.get_power_limit_CallbackFunctionPointer = Callback; } -void get_limit_Stub(CMOCK_get_limit_CALLBACK Callback) +void get_power_limit_Stub(CMOCK_get_power_limit_CALLBACK Callback) { - Mock.get_limit_IgnoreBool = (char)0; - Mock.get_limit_CallbackBool = (char)0; - Mock.get_limit_CallbackFunctionPointer = Callback; + Mock.get_power_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallbackBool = (char)0; + Mock.get_power_limit_CallbackFunctionPointer = Callback; } -void get_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return) +void get_power_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_limit(cmock_call_instance, id, power_limit, power_limit_Depth); + CMockExpectParameters_get_power_limit(cmock_call_instance, id, power_limit, power_limit_Depth); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size) +void get_power_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size) { - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); cmock_call_instance->ReturnThruPtr_power_limit_Used = 1; cmock_call_instance->ReturnThruPtr_power_limit_Val = power_limit; cmock_call_instance->ReturnThruPtr_power_limit_Size = cmock_size; } -void get_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +void get_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_id = 1; } -void get_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) +void get_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_power_limit = 1; } -int set_limit(fwk_id_t id, uint32_t power_limit) +int set_power_limit(fwk_id_t id, uint32_t power_limit) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_set_limit); - cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_limit_CallInstance); - Mock.set_limit_CallInstance = CMock_Guts_MemNext(Mock.set_limit_CallInstance); - if (Mock.set_limit_IgnoreBool) + CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_set_power_limit); + cmock_call_instance = (CMOCK_set_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_power_limit_CallInstance); + Mock.set_power_limit_CallInstance = CMock_Guts_MemNext(Mock.set_power_limit_CallInstance); + if (Mock.set_power_limit_IgnoreBool) { UNITY_CLR_DETAILS(); if (cmock_call_instance == NULL) - return Mock.set_limit_FinalReturn; - Mock.set_limit_FinalReturn = cmock_call_instance->ReturnVal; + return Mock.set_power_limit_FinalReturn; + Mock.set_power_limit_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } - if (!Mock.set_limit_CallbackBool && - Mock.set_limit_CallbackFunctionPointer != NULL) + if (!Mock.set_power_limit_CallbackBool && + Mock.set_power_limit_CallbackFunctionPointer != NULL) { - int cmock_cb_ret = Mock.set_limit_CallbackFunctionPointer(id, power_limit, Mock.set_limit_CallbackCalls++); + int cmock_cb_ret = Mock.set_power_limit_CallbackFunctionPointer(id, power_limit, Mock.set_power_limit_CallbackCalls++); UNITY_CLR_DETAILS(); return cmock_cb_ret; } @@ -293,25 +293,25 @@ int set_limit(fwk_id_t id, uint32_t power_limit) { if (!cmock_call_instance->IgnoreArg_id) { - UNITY_SET_DETAILS(CMockString_set_limit,CMockString_id); + UNITY_SET_DETAILS(CMockString_set_power_limit,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_limit) { - UNITY_SET_DETAILS(CMockString_set_limit,CMockString_power_limit); + UNITY_SET_DETAILS(CMockString_set_power_limit,CMockString_power_limit); UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_power_limit, power_limit, cmock_line, CMockStringMismatch); } } - if (Mock.set_limit_CallbackFunctionPointer != NULL) + if (Mock.set_power_limit_CallbackFunctionPointer != NULL) { - cmock_call_instance->ReturnVal = Mock.set_limit_CallbackFunctionPointer(id, power_limit, Mock.set_limit_CallbackCalls++); + cmock_call_instance->ReturnVal = Mock.set_power_limit_CallbackFunctionPointer(id, power_limit, Mock.set_power_limit_CallbackCalls++); } UNITY_CLR_DETAILS(); return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_set_limit(CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit); -void CMockExpectParameters_set_limit(CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit) +void CMockExpectParameters_set_power_limit(CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit); +void CMockExpectParameters_set_power_limit(CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit) { 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 */ @@ -320,79 +320,79 @@ void CMockExpectParameters_set_limit(CMOCK_set_limit_CALL_INSTANCE* cmock_call_i cmock_call_instance->IgnoreArg_power_limit = 0; } -void set_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void set_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_limit_CALL_INSTANCE)); - CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_limit_CALL_INSTANCE)); + CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.set_limit_CallInstance, cmock_guts_index); - Mock.set_limit_IgnoreBool = (char)0; + Mock.set_power_limit_CallInstance = CMock_Guts_MemChain(Mock.set_power_limit_CallInstance, cmock_guts_index); + Mock.set_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; - Mock.set_limit_IgnoreBool = (char)1; + Mock.set_power_limit_IgnoreBool = (char)1; } -void set_limit_CMockStopIgnore(void) +void set_power_limit_CMockStopIgnore(void) { - if(Mock.set_limit_IgnoreBool) - Mock.set_limit_CallInstance = CMock_Guts_MemNext(Mock.set_limit_CallInstance); - Mock.set_limit_IgnoreBool = (char)0; + if(Mock.set_power_limit_IgnoreBool) + Mock.set_power_limit_CallInstance = CMock_Guts_MemNext(Mock.set_power_limit_CallInstance); + Mock.set_power_limit_IgnoreBool = (char)0; } -void set_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void set_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_limit_CALL_INSTANCE)); - CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_limit_CALL_INSTANCE)); + CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.set_limit_CallInstance, cmock_guts_index); - Mock.set_limit_IgnoreBool = (char)0; + Mock.set_power_limit_CallInstance = CMock_Guts_MemChain(Mock.set_power_limit_CallInstance, cmock_guts_index); + Mock.set_power_limit_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_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return) +void set_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_limit_CALL_INSTANCE)); - CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_limit_CALL_INSTANCE)); + CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.set_limit_CallInstance, cmock_guts_index); - Mock.set_limit_IgnoreBool = (char)0; + Mock.set_power_limit_CallInstance = CMock_Guts_MemChain(Mock.set_power_limit_CallInstance, cmock_guts_index); + Mock.set_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_set_limit(cmock_call_instance, id, power_limit); + CMockExpectParameters_set_power_limit(cmock_call_instance, id, power_limit); cmock_call_instance->ReturnVal = cmock_to_return; } -void set_limit_AddCallback(CMOCK_set_limit_CALLBACK Callback) +void set_power_limit_AddCallback(CMOCK_set_power_limit_CALLBACK Callback) { - Mock.set_limit_IgnoreBool = (char)0; - Mock.set_limit_CallbackBool = (char)1; - Mock.set_limit_CallbackFunctionPointer = Callback; + Mock.set_power_limit_IgnoreBool = (char)0; + Mock.set_power_limit_CallbackBool = (char)1; + Mock.set_power_limit_CallbackFunctionPointer = Callback; } -void set_limit_Stub(CMOCK_set_limit_CALLBACK Callback) +void set_power_limit_Stub(CMOCK_set_power_limit_CALLBACK Callback) { - Mock.set_limit_IgnoreBool = (char)0; - Mock.set_limit_CallbackBool = (char)0; - Mock.set_limit_CallbackFunctionPointer = Callback; + Mock.set_power_limit_IgnoreBool = (char)0; + Mock.set_power_limit_CallbackBool = (char)0; + Mock.set_power_limit_CallbackFunctionPointer = Callback; } -void set_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +void set_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) { - CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_limit_CallInstance)); + CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_id = 1; } -void set_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) +void set_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) { - CMOCK_set_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_limit_CallInstance)); + CMOCK_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_power_limit = 1; } diff --git a/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.h b/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.h index bee5143a2..81f2bc784 100644 --- a/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.h +++ b/module/metrics_analyzer/test/mocks/Mockmod_metrics_analyzer_extra.h @@ -24,44 +24,44 @@ void Mockmod_metrics_analyzer_extra_Verify(void); -#define get_limit_IgnoreAndReturn(cmock_retval) get_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_limit_StopIgnore() get_limit_CMockStopIgnore() -void get_limit_CMockStopIgnore(void); -#define get_limit_ExpectAnyArgsAndReturn(cmock_retval) get_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_limit_ExpectAndReturn(id, power_limit, cmock_retval) get_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) -void get_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return); -typedef int (* CMOCK_get_limit_CALLBACK)(fwk_id_t id, uint32_t* power_limit, int cmock_num_calls); -void get_limit_AddCallback(CMOCK_get_limit_CALLBACK Callback); -void get_limit_Stub(CMOCK_get_limit_CALLBACK Callback); -#define get_limit_StubWithCallback get_limit_Stub -#define get_limit_ExpectWithArrayAndReturn(id, power_limit, power_limit_Depth, cmock_retval) get_limit_CMockExpectWithArrayAndReturn(__LINE__, id, power_limit, power_limit_Depth, cmock_retval) -void get_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return); -#define get_limit_ReturnThruPtr_power_limit(power_limit) get_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, sizeof(uint32_t)) -#define get_limit_ReturnArrayThruPtr_power_limit(power_limit, cmock_len) get_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_len * sizeof(*power_limit)) -#define get_limit_ReturnMemThruPtr_power_limit(power_limit, cmock_size) get_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_size) -void get_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size); -#define get_limit_IgnoreArg_id() get_limit_CMockIgnoreArg_id(__LINE__) -void get_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); -#define get_limit_IgnoreArg_power_limit() get_limit_CMockIgnoreArg_power_limit(__LINE__) -void get_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line); -#define set_limit_IgnoreAndReturn(cmock_retval) set_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void set_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_limit_StopIgnore() set_limit_CMockStopIgnore() -void set_limit_CMockStopIgnore(void); -#define set_limit_ExpectAnyArgsAndReturn(cmock_retval) set_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void set_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_limit_ExpectAndReturn(id, power_limit, cmock_retval) set_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) -void set_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return); -typedef int (* CMOCK_set_limit_CALLBACK)(fwk_id_t id, uint32_t power_limit, int cmock_num_calls); -void set_limit_AddCallback(CMOCK_set_limit_CALLBACK Callback); -void set_limit_Stub(CMOCK_set_limit_CALLBACK Callback); -#define set_limit_StubWithCallback set_limit_Stub -#define set_limit_IgnoreArg_id() set_limit_CMockIgnoreArg_id(__LINE__) -void set_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); -#define set_limit_IgnoreArg_power_limit() set_limit_CMockIgnoreArg_power_limit(__LINE__) -void set_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line); +#define get_power_limit_IgnoreAndReturn(cmock_retval) get_power_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_power_limit_StopIgnore() get_power_limit_CMockStopIgnore() +void get_power_limit_CMockStopIgnore(void); +#define get_power_limit_ExpectAnyArgsAndReturn(cmock_retval) get_power_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_power_limit_ExpectAndReturn(id, power_limit, cmock_retval) get_power_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) +void get_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return); +typedef int (* CMOCK_get_power_limit_CALLBACK)(fwk_id_t id, uint32_t* power_limit, int cmock_num_calls); +void get_power_limit_AddCallback(CMOCK_get_power_limit_CALLBACK Callback); +void get_power_limit_Stub(CMOCK_get_power_limit_CALLBACK Callback); +#define get_power_limit_StubWithCallback get_power_limit_Stub +#define get_power_limit_ExpectWithArrayAndReturn(id, power_limit, power_limit_Depth, cmock_retval) get_power_limit_CMockExpectWithArrayAndReturn(__LINE__, id, power_limit, power_limit_Depth, cmock_retval) +void get_power_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return); +#define get_power_limit_ReturnThruPtr_power_limit(power_limit) get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, sizeof(uint32_t)) +#define get_power_limit_ReturnArrayThruPtr_power_limit(power_limit, cmock_len) get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_len * sizeof(*power_limit)) +#define get_power_limit_ReturnMemThruPtr_power_limit(power_limit, cmock_size) get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_size) +void get_power_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size); +#define get_power_limit_IgnoreArg_id() get_power_limit_CMockIgnoreArg_id(__LINE__) +void get_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_power_limit_IgnoreArg_power_limit() get_power_limit_CMockIgnoreArg_power_limit(__LINE__) +void get_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line); +#define set_power_limit_IgnoreAndReturn(cmock_retval) set_power_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void set_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_power_limit_StopIgnore() set_power_limit_CMockStopIgnore() +void set_power_limit_CMockStopIgnore(void); +#define set_power_limit_ExpectAnyArgsAndReturn(cmock_retval) set_power_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void set_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_power_limit_ExpectAndReturn(id, power_limit, cmock_retval) set_power_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) +void set_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return); +typedef int (* CMOCK_set_power_limit_CALLBACK)(fwk_id_t id, uint32_t power_limit, int cmock_num_calls); +void set_power_limit_AddCallback(CMOCK_set_power_limit_CALLBACK Callback); +void set_power_limit_Stub(CMOCK_set_power_limit_CALLBACK Callback); +#define set_power_limit_StubWithCallback set_power_limit_Stub +#define set_power_limit_IgnoreArg_id() set_power_limit_CMockIgnoreArg_id(__LINE__) +void set_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define set_power_limit_IgnoreArg_power_limit() set_power_limit_CMockIgnoreArg_power_limit(__LINE__) +void set_power_limit_CMockIgnoreArg_power_limit(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/metrics_analyzer/test/mod_metrics_analyzer_extra.h b/module/metrics_analyzer/test/mod_metrics_analyzer_extra.h index 18ebfd92a..78b241c2a 100644 --- a/module/metrics_analyzer/test/mod_metrics_analyzer_extra.h +++ b/module/metrics_analyzer/test/mod_metrics_analyzer_extra.h @@ -13,7 +13,7 @@ #include -int get_limit(fwk_id_t id, uint32_t *power_limit); -int set_limit(fwk_id_t id, uint32_t power_limit); +int get_power_limit(fwk_id_t id, uint32_t *power_limit); +int set_power_limit(fwk_id_t id, uint32_t power_limit); #endif /* MOD_METRICS_ANALYZER_EXTRA_H */ diff --git a/module/metrics_analyzer/test/mod_metrics_analyzer_unit_test.c b/module/metrics_analyzer/test/mod_metrics_analyzer_unit_test.c index 036570012..3fd49db8d 100644 --- a/module/metrics_analyzer/test/mod_metrics_analyzer_unit_test.c +++ b/module/metrics_analyzer/test/mod_metrics_analyzer_unit_test.c @@ -31,8 +31,8 @@ static struct mod_domain_ctx domains[METRICS_ANALYZER_DOMAIN_IDX_COUNT]; static struct mod_metric_ctx metrics[METRICS_ANALYZER_DOMAIN_IDX_COUNT] [METRICS_ANALYZER_METRIC_IDX_COUNT]; struct interface_power_management_api limit_api = { - .get_limit = &get_limit, - .set_limit = &set_limit, + .get_power_limit = &get_power_limit, + .set_power_limit = &set_power_limit, }; void setUp(void) @@ -306,12 +306,13 @@ void test_collect_domain_limits_first_time(void) /* Expected calls */ for (size_t i = 0; i < domain_ctx.metrics_count; ++i) { - get_limit_ExpectAndReturn( + get_power_limit_ExpectAndReturn( limit_provider_config[i].domain_id, NULL, FWK_SUCCESS); - get_limit_IgnoreArg_power_limit(); - get_limit_ReturnMemThruPtr_power_limit(&limits[i], sizeof(limits[i])); + get_power_limit_IgnoreArg_power_limit(); + get_power_limit_ReturnMemThruPtr_power_limit( + &limits[i], sizeof(limits[i])); } - get_limit_StopIgnore(); + get_power_limit_StopIgnore(); /* Test */ status = collect_domain_limits(&domain_ctx); @@ -363,13 +364,13 @@ void test_collect_domain_limits(void) /* Expected calls */ for (size_t i = 0; i < domain_ctx.metrics_count; ++i) { - get_limit_ExpectAndReturn( + get_power_limit_ExpectAndReturn( limit_provider_config[i].domain_id, NULL, FWK_SUCCESS); - get_limit_IgnoreArg_power_limit(); - get_limit_ReturnMemThruPtr_power_limit( + get_power_limit_IgnoreArg_power_limit(); + get_power_limit_ReturnMemThruPtr_power_limit( &new_limits[i], sizeof(new_limits[i])); } - get_limit_StopIgnore(); + get_power_limit_StopIgnore(); /* Test */ status = collect_domain_limits(&domain_ctx); @@ -421,13 +422,13 @@ void test_collect_domain_limits_no_power_limit(void) /* Expected calls */ for (size_t i = 0; i < domain_ctx.metrics_count; ++i) { - get_limit_ExpectAndReturn( + get_power_limit_ExpectAndReturn( limit_provider_config[i].domain_id, NULL, FWK_SUCCESS); - get_limit_IgnoreArg_power_limit(); - get_limit_ReturnMemThruPtr_power_limit( + get_power_limit_IgnoreArg_power_limit(); + get_power_limit_ReturnMemThruPtr_power_limit( &new_limits[i], sizeof(new_limits[i])); } - get_limit_StopIgnore(); + get_power_limit_StopIgnore(); /* Test */ status = collect_domain_limits(&domain_ctx); @@ -478,12 +479,13 @@ void test_collect_domain_limits_no_change_domain(void) /* Expected calls */ for (size_t i = 0; i < domain_ctx.metrics_count; ++i) { - get_limit_ExpectAndReturn( + get_power_limit_ExpectAndReturn( limit_provider_config[i].domain_id, NULL, FWK_SUCCESS); - get_limit_IgnoreArg_power_limit(); - get_limit_ReturnMemThruPtr_power_limit(&limits[i], sizeof(limits[i])); + get_power_limit_IgnoreArg_power_limit(); + get_power_limit_ReturnMemThruPtr_power_limit( + &limits[i], sizeof(limits[i])); } - get_limit_StopIgnore(); + get_power_limit_StopIgnore(); /* Test */ status = collect_domain_limits(&domain_ctx); @@ -525,7 +527,7 @@ void test_report_domain_aggregate_limit(void) }; /* Expected calls */ - set_limit_ExpectAndReturn( + set_power_limit_ExpectAndReturn( domain_ctx.config->limit_consumer.domain_id, domain_ctx.aggregate_limit, FWK_SUCCESS); diff --git a/module/mpmm_v2/src/mod_mpmm_v2.c b/module/mpmm_v2/src/mod_mpmm_v2.c index eded9b1e7..64d25cef4 100644 --- a/module/mpmm_v2/src/mod_mpmm_v2.c +++ b/module/mpmm_v2/src/mod_mpmm_v2.c @@ -429,7 +429,7 @@ static int handle_pd_notification( return FWK_SUCCESS; } -static int mpmm_v2_get_limit(fwk_id_t domain_id, uint32_t *power_limit) +static int mpmm_v2_get_power_limit(fwk_id_t domain_id, uint32_t *power_limit) { struct mod_mpmm_v2_domain_ctx *domain_ctx; uint32_t domain_idx; @@ -481,8 +481,8 @@ static int mpmm_v2_get_limit(fwk_id_t domain_id, uint32_t *power_limit) } static struct interface_power_management_api mpmm_v2_pm_api = { - .get_limit = mpmm_v2_get_limit, - .set_limit = NULL, + .get_power_limit = mpmm_v2_get_power_limit, + .set_power_limit = NULL, }; /* diff --git a/module/mpmm_v2/test/mod_mpmm_v2_unit_test.c b/module/mpmm_v2/test/mod_mpmm_v2_unit_test.c index 8a018baba..874500c1b 100644 --- a/module/mpmm_v2/test/mod_mpmm_v2_unit_test.c +++ b/module/mpmm_v2/test/mod_mpmm_v2_unit_test.c @@ -742,7 +742,7 @@ void utest_mpmm_v2_evaluate_power_limit_2_cores_online_least_aggressive_gear( TEST_ASSERT_EQUAL(expected_power_limit, eval_power_limit); } -void utest_mpmm_v2_get_limit_success(void) +void utest_mpmm_v2_get_power_limit_success(void) { int status; struct mod_mpmm_v2_domain_ctx *domain_ctx = mpmm_v2_ctx.domain_ctx; @@ -756,12 +756,12 @@ void utest_mpmm_v2_get_limit_success(void) fwk_id_is_equal_ExpectAndReturn( domain_ctx->domain_config->perf_id, perf_id, true); - status = mpmm_v2_get_limit(domain_ctx->domain_id, &power_limit); + status = mpmm_v2_get_power_limit(domain_ctx->domain_id, &power_limit); TEST_ASSERT_EQUAL(FWK_SUCCESS, status); TEST_ASSERT_EQUAL(domain_ctx->power_limit, power_limit); } -void utest_mpmm_v2_get_limit_domain_idx_not_found(void) +void utest_mpmm_v2_get_power_limit_domain_idx_not_found(void) { int status; uint32_t power_limit = UINT32_MAX; @@ -772,12 +772,12 @@ void utest_mpmm_v2_get_limit_domain_idx_not_found(void) fwk_id_is_equal_ExpectAndReturn( mpmm_v2_ctx.domain_ctx->domain_config->perf_id, perf_id, false); - status = mpmm_v2_get_limit(mpmm_v2_domain_id, &power_limit); + status = mpmm_v2_get_power_limit(mpmm_v2_domain_id, &power_limit); TEST_ASSERT_EQUAL(FWK_E_PARAM, status); TEST_ASSERT_EQUAL(UINT32_MAX, power_limit); } -void utest_mpmm_v2_get_limit_no_cores_online(void) +void utest_mpmm_v2_get_power_limit_no_cores_online(void) { int status; struct mod_mpmm_v2_domain_ctx *domain_ctx = mpmm_v2_ctx.domain_ctx; @@ -791,12 +791,12 @@ void utest_mpmm_v2_get_limit_no_cores_online(void) fwk_id_is_equal_ExpectAndReturn( mpmm_v2_ctx.domain_ctx->domain_config->perf_id, perf_id, true); - status = mpmm_v2_get_limit(mpmm_v2_domain_id, &power_limit); + status = mpmm_v2_get_power_limit(mpmm_v2_domain_id, &power_limit); TEST_ASSERT_EQUAL(FWK_SUCCESS, status); TEST_ASSERT_EQUAL(domain_ctx->domain_config->max_power, power_limit); } -void utest_mpmm_v2_get_limit_wait_for_perf_trasition(void) +void utest_mpmm_v2_get_power_limit_wait_for_perf_trasition(void) { int status; struct mod_mpmm_v2_domain_ctx *domain_ctx = mpmm_v2_ctx.domain_ctx; @@ -829,7 +829,7 @@ void utest_mpmm_v2_get_limit_wait_for_perf_trasition(void) amu_mmap_get_counters_ReturnMemThruPtr_counter_buff( &(test_amu_counter[AMU_AUX0]), sizeof(uint64_t) * config->num_of_gears); - status = mpmm_v2_get_limit(mpmm_v2_domain_id, &power_limit); + status = mpmm_v2_get_power_limit(mpmm_v2_domain_id, &power_limit); TEST_ASSERT_EQUAL(FWK_SUCCESS, status); TEST_ASSERT_EQUAL(power_limit, config->max_power); TEST_ASSERT_TRUE(mpmm_v2_ctx.domain_ctx->wait_for_perf_transition); @@ -1244,10 +1244,10 @@ int mod_mpmm_v2_test_main(void) RUN_TEST( utest_mpmm_v2_evaluate_power_limit_2_cores_online_least_aggressive_gear); - RUN_TEST(utest_mpmm_v2_get_limit_success); - RUN_TEST(utest_mpmm_v2_get_limit_domain_idx_not_found); - RUN_TEST(utest_mpmm_v2_get_limit_no_cores_online); - RUN_TEST(utest_mpmm_v2_get_limit_wait_for_perf_trasition); + RUN_TEST(utest_mpmm_v2_get_power_limit_success); + RUN_TEST(utest_mpmm_v2_get_power_limit_domain_idx_not_found); + RUN_TEST(utest_mpmm_v2_get_power_limit_no_cores_online); + RUN_TEST(utest_mpmm_v2_get_power_limit_wait_for_perf_trasition); RUN_TEST(utest_mpmm_v2_controller_noti_not_waiting_perf_transition_success); RUN_TEST( diff --git a/module/perf_controller/src/mod_perf_controller.c b/module/perf_controller/src/mod_perf_controller.c index 40c742917..dcd611d79 100644 --- a/module/perf_controller/src/mod_perf_controller.c +++ b/module/perf_controller/src/mod_perf_controller.c @@ -101,7 +101,9 @@ static struct mod_perf_controller_perf_api perf_api = { .set_performance_level = mod_perf_controller_set_performance_level, }; -static int mod_perf_controller_set_limit(fwk_id_t core_id, uint32_t power_limit) +static int mod_perf_controller_set_power_limit( + fwk_id_t core_id, + uint32_t power_limit) { unsigned int core_idx; unsigned int cluster_idx; @@ -123,7 +125,7 @@ static int mod_perf_controller_set_limit(fwk_id_t core_id, uint32_t power_limit) } static struct interface_power_management_api power_api = { - .set_limit = mod_perf_controller_set_limit, + .set_power_limit = mod_perf_controller_set_power_limit, }; static int mod_perf_controller_apply_performance_granted(void) diff --git a/module/perf_controller/test/mod_perf_controller_unit_test.c b/module/perf_controller/test/mod_perf_controller_unit_test.c index 9bf0c55d4..7a95e4583 100644 --- a/module/perf_controller/test/mod_perf_controller_unit_test.c +++ b/module/perf_controller/test/mod_perf_controller_unit_test.c @@ -141,7 +141,7 @@ void test_set_performance_level_out_of_limits(void) } } -void test_set_limit_success(void) +void test_set_power_limit_success(void) { int status; fwk_id_t core_id; @@ -162,7 +162,7 @@ void test_set_limit_success(void) .core_ctx_table[core_idx]; power_limit = 20U; - status = mod_perf_controller_set_limit(core_id, power_limit); + status = mod_perf_controller_set_power_limit(core_id, power_limit); TEST_ASSERT_EQUAL(core_ctx->power_limit, power_limit); TEST_ASSERT_EQUAL(status, FWK_SUCCESS); @@ -326,7 +326,7 @@ int perf_controller_test_main(void) RUN_TEST(test_set_performance_level_within_limits); RUN_TEST(test_set_performance_level_out_of_limits); - RUN_TEST(test_set_limit_success); + RUN_TEST(test_set_power_limit_success); RUN_TEST(test_get_cores_min_power_limit); RUN_TEST(test_controller_apply_performance_granted_within_limits); RUN_TEST(test_controller_apply_performance_granted_out_of_limits); diff --git a/module/power_capping/src/mod_power_capping.c b/module/power_capping/src/mod_power_capping.c index 01a10b281..cf1d99bf5 100644 --- a/module/power_capping/src/mod_power_capping.c +++ b/module/power_capping/src/mod_power_capping.c @@ -87,7 +87,9 @@ static int mod_pcapping_get_applied_cap(fwk_id_t domain_id, uint32_t *cap) return FWK_SUCCESS; } -static int mod_pcapping_get_limit(fwk_id_t domain_id, uint32_t *power_limit) +static int mod_pcapping_get_power_limit( + fwk_id_t domain_id, + uint32_t *power_limit) { int status; struct pcapping_domain_ctx *domain_ctx; @@ -108,7 +110,7 @@ struct mod_power_capping_api pcapping_api = { }; struct interface_power_management_api power_management_api = { - .get_limit = mod_pcapping_get_limit, + .get_power_limit = mod_pcapping_get_power_limit, }; int pcapping_init( @@ -153,7 +155,7 @@ static int mod_pcapping_process_notification( if (fwk_id_is_equal( event->id, domain_ctx->config->power_limit_set_notification_id)) { - status = domain_ctx->power_management_api->get_limit( + status = domain_ctx->power_management_api->get_power_limit( domain_ctx->config->power_limiter_id, &applied_cap); if (status != FWK_SUCCESS) { 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 b79beefb4..afd477d7a 100644 --- a/module/power_capping/test/mocks/Mockmod_power_capping_extra.c +++ b/module/power_capping/test/mocks/Mockmod_power_capping_extra.c @@ -5,11 +5,11 @@ #include "cmock.h" #include "Mockmod_power_capping_extra.h" -static const char* CMockString_get_limit = "get_limit"; +static const char* CMockString_get_power_limit = "get_power_limit"; static const char* CMockString_id = "id"; static const char* CMockString_power_limit = "power_limit"; -typedef struct _CMOCK_get_limit_CALL_INSTANCE +typedef struct _CMOCK_get_power_limit_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; @@ -23,16 +23,16 @@ typedef struct _CMOCK_get_limit_CALL_INSTANCE char IgnoreArg_id; char IgnoreArg_power_limit; -} CMOCK_get_limit_CALL_INSTANCE; +} CMOCK_get_power_limit_CALL_INSTANCE; static struct Mockmod_power_capping_extraInstance { - char get_limit_IgnoreBool; - int get_limit_FinalReturn; - char get_limit_CallbackBool; - CMOCK_get_limit_CALLBACK get_limit_CallbackFunctionPointer; - int get_limit_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_limit_CallInstance; + char get_power_limit_IgnoreBool; + int get_power_limit_FinalReturn; + char get_power_limit_CallbackBool; + CMOCK_get_power_limit_CALLBACK get_power_limit_CallbackFunctionPointer; + int get_power_limit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_power_limit_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -41,15 +41,15 @@ void Mockmod_power_capping_extra_Verify(void) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; CMOCK_MEM_INDEX_TYPE call_instance; - call_instance = Mock.get_limit_CallInstance; - if (Mock.get_limit_IgnoreBool) + call_instance = Mock.get_power_limit_CallInstance; + if (Mock.get_power_limit_IgnoreBool) call_instance = CMOCK_GUTS_NONE; if (CMOCK_GUTS_NONE != call_instance) { - UNITY_SET_DETAIL(CMockString_get_limit); + UNITY_SET_DETAIL(CMockString_get_power_limit); UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } - if (Mock.get_limit_CallbackFunctionPointer != NULL) + if (Mock.get_power_limit_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; @@ -67,25 +67,25 @@ void Mockmod_power_capping_extra_Destroy(void) memset(&Mock, 0, sizeof(Mock)); } -int get_limit(fwk_id_t id, uint32_t* power_limit) +int get_power_limit(fwk_id_t id, uint32_t* power_limit) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_limit); - cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_limit_CallInstance); - Mock.get_limit_CallInstance = CMock_Guts_MemNext(Mock.get_limit_CallInstance); - if (Mock.get_limit_IgnoreBool) + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_power_limit); + cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_power_limit_CallInstance); + Mock.get_power_limit_CallInstance = CMock_Guts_MemNext(Mock.get_power_limit_CallInstance); + if (Mock.get_power_limit_IgnoreBool) { UNITY_CLR_DETAILS(); if (cmock_call_instance == NULL) - return Mock.get_limit_FinalReturn; - Mock.get_limit_FinalReturn = cmock_call_instance->ReturnVal; + return Mock.get_power_limit_FinalReturn; + Mock.get_power_limit_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } - if (!Mock.get_limit_CallbackBool && - Mock.get_limit_CallbackFunctionPointer != NULL) + if (!Mock.get_power_limit_CallbackBool && + Mock.get_power_limit_CallbackFunctionPointer != NULL) { - int cmock_cb_ret = Mock.get_limit_CallbackFunctionPointer(id, power_limit, Mock.get_limit_CallbackCalls++); + int cmock_cb_ret = Mock.get_power_limit_CallbackFunctionPointer(id, power_limit, Mock.get_power_limit_CallbackCalls++); UNITY_CLR_DETAILS(); return cmock_cb_ret; } @@ -95,21 +95,21 @@ int get_limit(fwk_id_t id, uint32_t* power_limit) { if (!cmock_call_instance->IgnoreArg_id) { - UNITY_SET_DETAILS(CMockString_get_limit,CMockString_id); + UNITY_SET_DETAILS(CMockString_get_power_limit,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_limit) { - UNITY_SET_DETAILS(CMockString_get_limit,CMockString_power_limit); + UNITY_SET_DETAILS(CMockString_get_power_limit,CMockString_power_limit); if (cmock_call_instance->Expected_power_limit == NULL) { UNITY_TEST_ASSERT_NULL(power_limit, cmock_line, CMockStringExpNULL); } else { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power_limit, power_limit, cmock_call_instance->Expected_power_limit_Depth, cmock_line, CMockStringMismatch); } } } - if (Mock.get_limit_CallbackFunctionPointer != NULL) + if (Mock.get_power_limit_CallbackFunctionPointer != NULL) { - cmock_call_instance->ReturnVal = Mock.get_limit_CallbackFunctionPointer(id, power_limit, Mock.get_limit_CallbackCalls++); + cmock_call_instance->ReturnVal = Mock.get_power_limit_CallbackFunctionPointer(id, power_limit, Mock.get_power_limit_CallbackCalls++); } if (cmock_call_instance->ReturnThruPtr_power_limit_Used) { @@ -121,8 +121,8 @@ int get_limit(fwk_id_t id, uint32_t* power_limit) return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth); -void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth) +void CMockExpectParameters_get_power_limit(CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth); +void CMockExpectParameters_get_power_limit(CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_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 */ @@ -133,102 +133,102 @@ void CMockExpectParameters_get_limit(CMOCK_get_limit_CALL_INSTANCE* cmock_call_i cmock_call_instance->ReturnThruPtr_power_limit_Used = 0; } -void get_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_limit_IgnoreBool = (char)1; + Mock.get_power_limit_IgnoreBool = (char)1; } -void get_limit_CMockStopIgnore(void) +void get_power_limit_CMockStopIgnore(void) { - if(Mock.get_limit_IgnoreBool) - Mock.get_limit_CallInstance = CMock_Guts_MemNext(Mock.get_limit_CallInstance); - Mock.get_limit_IgnoreBool = (char)0; + if(Mock.get_power_limit_IgnoreBool) + Mock.get_power_limit_CallInstance = CMock_Guts_MemNext(Mock.get_power_limit_CallInstance); + Mock.get_power_limit_IgnoreBool = (char)0; } -void get_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_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_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return) +void get_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_limit(cmock_call_instance, id, power_limit, 1); + CMockExpectParameters_get_power_limit(cmock_call_instance, id, power_limit, 1); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_limit_AddCallback(CMOCK_get_limit_CALLBACK Callback) +void get_power_limit_AddCallback(CMOCK_get_power_limit_CALLBACK Callback) { - Mock.get_limit_IgnoreBool = (char)0; - Mock.get_limit_CallbackBool = (char)1; - Mock.get_limit_CallbackFunctionPointer = Callback; + Mock.get_power_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallbackBool = (char)1; + Mock.get_power_limit_CallbackFunctionPointer = Callback; } -void get_limit_Stub(CMOCK_get_limit_CALLBACK Callback) +void get_power_limit_Stub(CMOCK_get_power_limit_CALLBACK Callback) { - Mock.get_limit_IgnoreBool = (char)0; - Mock.get_limit_CallbackBool = (char)0; - Mock.get_limit_CallbackFunctionPointer = Callback; + Mock.get_power_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallbackBool = (char)0; + Mock.get_power_limit_CallbackFunctionPointer = Callback; } -void get_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return) +void get_power_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_limit_CALL_INSTANCE)); - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_limit_CALL_INSTANCE)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_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_limit_CallInstance = CMock_Guts_MemChain(Mock.get_limit_CallInstance, cmock_guts_index); - Mock.get_limit_IgnoreBool = (char)0; + Mock.get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.get_power_limit_CallInstance, cmock_guts_index); + Mock.get_power_limit_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_limit(cmock_call_instance, id, power_limit, power_limit_Depth); + CMockExpectParameters_get_power_limit(cmock_call_instance, id, power_limit, power_limit_Depth); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size) +void get_power_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size) { - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); cmock_call_instance->ReturnThruPtr_power_limit_Used = 1; cmock_call_instance->ReturnThruPtr_power_limit_Val = power_limit; cmock_call_instance->ReturnThruPtr_power_limit_Size = cmock_size; } -void get_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +void get_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_id = 1; } -void get_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) +void get_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_limit_CallInstance)); + CMOCK_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_limit_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_power_limit = 1; } diff --git a/module/power_capping/test/mocks/Mockmod_power_capping_extra.h b/module/power_capping/test/mocks/Mockmod_power_capping_extra.h index a628b6e01..897313c62 100644 --- a/module/power_capping/test/mocks/Mockmod_power_capping_extra.h +++ b/module/power_capping/test/mocks/Mockmod_power_capping_extra.h @@ -24,28 +24,28 @@ void Mockmod_power_capping_extra_Verify(void); -#define get_limit_IgnoreAndReturn(cmock_retval) get_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_limit_StopIgnore() get_limit_CMockStopIgnore() -void get_limit_CMockStopIgnore(void); -#define get_limit_ExpectAnyArgsAndReturn(cmock_retval) get_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_limit_ExpectAndReturn(id, power_limit, cmock_retval) get_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) -void get_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return); -typedef int (* CMOCK_get_limit_CALLBACK)(fwk_id_t id, uint32_t* power_limit, int cmock_num_calls); -void get_limit_AddCallback(CMOCK_get_limit_CALLBACK Callback); -void get_limit_Stub(CMOCK_get_limit_CALLBACK Callback); -#define get_limit_StubWithCallback get_limit_Stub -#define get_limit_ExpectWithArrayAndReturn(id, power_limit, power_limit_Depth, cmock_retval) get_limit_CMockExpectWithArrayAndReturn(__LINE__, id, power_limit, power_limit_Depth, cmock_retval) -void get_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return); -#define get_limit_ReturnThruPtr_power_limit(power_limit) get_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, sizeof(uint32_t)) -#define get_limit_ReturnArrayThruPtr_power_limit(power_limit, cmock_len) get_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_len * sizeof(*power_limit)) -#define get_limit_ReturnMemThruPtr_power_limit(power_limit, cmock_size) get_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_size) -void get_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size); -#define get_limit_IgnoreArg_id() get_limit_CMockIgnoreArg_id(__LINE__) -void get_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); -#define get_limit_IgnoreArg_power_limit() get_limit_CMockIgnoreArg_power_limit(__LINE__) -void get_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line); +#define get_power_limit_IgnoreAndReturn(cmock_retval) get_power_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_power_limit_StopIgnore() get_power_limit_CMockStopIgnore() +void get_power_limit_CMockStopIgnore(void); +#define get_power_limit_ExpectAnyArgsAndReturn(cmock_retval) get_power_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_power_limit_ExpectAndReturn(id, power_limit, cmock_retval) get_power_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) +void get_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return); +typedef int (* CMOCK_get_power_limit_CALLBACK)(fwk_id_t id, uint32_t* power_limit, int cmock_num_calls); +void get_power_limit_AddCallback(CMOCK_get_power_limit_CALLBACK Callback); +void get_power_limit_Stub(CMOCK_get_power_limit_CALLBACK Callback); +#define get_power_limit_StubWithCallback get_power_limit_Stub +#define get_power_limit_ExpectWithArrayAndReturn(id, power_limit, power_limit_Depth, cmock_retval) get_power_limit_CMockExpectWithArrayAndReturn(__LINE__, id, power_limit, power_limit_Depth, cmock_retval) +void get_power_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return); +#define get_power_limit_ReturnThruPtr_power_limit(power_limit) get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, sizeof(uint32_t)) +#define get_power_limit_ReturnArrayThruPtr_power_limit(power_limit, cmock_len) get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_len * sizeof(*power_limit)) +#define get_power_limit_ReturnMemThruPtr_power_limit(power_limit, cmock_size) get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_size) +void get_power_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size); +#define get_power_limit_IgnoreArg_id() get_power_limit_CMockIgnoreArg_id(__LINE__) +void get_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_power_limit_IgnoreArg_power_limit() get_power_limit_CMockIgnoreArg_power_limit(__LINE__) +void get_power_limit_CMockIgnoreArg_power_limit(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/power_capping/test/mod_power_capping_extra.h b/module/power_capping/test/mod_power_capping_extra.h index a32122a7f..149cce37e 100644 --- a/module/power_capping/test/mod_power_capping_extra.h +++ b/module/power_capping/test/mod_power_capping_extra.h @@ -8,4 +8,4 @@ #include "fwk_event.h" -int get_limit(fwk_id_t id, uint32_t *power_limit); +int get_power_limit(fwk_id_t id, uint32_t *power_limit); diff --git a/module/power_capping/test/mod_power_capping_unit_test.c b/module/power_capping/test/mod_power_capping_unit_test.c index a6380ac39..a090c0a79 100644 --- a/module/power_capping/test/mod_power_capping_unit_test.c +++ b/module/power_capping/test/mod_power_capping_unit_test.c @@ -29,7 +29,7 @@ struct pcapping_domain_ctx test_ctx_table[TEST_DOMAIN_COUNT]; struct interface_power_management_api test_power_management_api = { - .get_limit = get_limit, + .get_power_limit = get_power_limit, }; void setUp(void) @@ -164,7 +164,7 @@ void utest_mod_pcapping_get_applied_cap_e_param(void) TEST_ASSERT_EQUAL(status, FWK_E_PARAM); } -void utest_mod_pcapping_get_limit_success(void) +void utest_mod_pcapping_get_power_limit_success(void) { int status; fwk_id_t domain_id; @@ -178,13 +178,13 @@ void utest_mod_pcapping_get_limit_success(void) domain_ctx->requested_cap = requested_cap; - status = mod_pcapping_get_limit(domain_id, &limit); + status = mod_pcapping_get_power_limit(domain_id, &limit); TEST_ASSERT_EQUAL(status, FWK_SUCCESS); TEST_ASSERT_EQUAL(requested_cap, limit); } } -void utest_mod_pcapping_get_limit_e_param(void) +void utest_mod_pcapping_get_power_limit_e_param(void) { int status; uint32_t limit; @@ -192,7 +192,7 @@ void utest_mod_pcapping_get_limit_e_param(void) fwk_id_t domain_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_CAPPING, TEST_DOMAIN_COUNT); - status = mod_pcapping_get_limit(domain_id, &limit); + status = mod_pcapping_get_power_limit(domain_id, &limit); TEST_ASSERT_EQUAL(status, FWK_E_PARAM); } @@ -244,10 +244,10 @@ void utest_mod_pcapping_process_notification_success(void) }; uint32_t applied_cap = 44U + index; - get_limit_ExpectAndReturn( + get_power_limit_ExpectAndReturn( domain_ctx->config->power_limiter_id, NULL, FWK_SUCCESS); - get_limit_IgnoreArg_power_limit(); - get_limit_ReturnThruPtr_power_limit(&applied_cap); + get_power_limit_IgnoreArg_power_limit(); + get_power_limit_ReturnThruPtr_power_limit(&applied_cap); struct fwk_event outbound_notification = { .source_id = domain_id, .id = FWK_ID_NOTIFICATION_INIT( @@ -416,8 +416,8 @@ int power_capping_test_main(void) RUN_TEST(utest_mod_pcapping_request_cap_e_param); RUN_TEST(utest_mod_pcapping_get_applied_cap_success); RUN_TEST(utest_mod_pcapping_get_applied_cap_e_param); - RUN_TEST(utest_mod_pcapping_get_limit_success); - RUN_TEST(utest_mod_pcapping_get_limit_e_param); + RUN_TEST(utest_mod_pcapping_get_power_limit_success); + RUN_TEST(utest_mod_pcapping_get_power_limit_e_param); RUN_TEST(utest_pcapping_init_success); RUN_TEST(utest_pcapping_domain_init_success); RUN_TEST(utest_mod_pcapping_process_notification_success); diff --git a/module/thermal_power_estimator/src/mod_thermal_power_estimator.c b/module/thermal_power_estimator/src/mod_thermal_power_estimator.c index 8988bfdd2..d2e4362ce 100644 --- a/module/thermal_power_estimator/src/mod_thermal_power_estimator.c +++ b/module/thermal_power_estimator/src/mod_thermal_power_estimator.c @@ -144,8 +144,8 @@ static int thermal_power_estimator_set_limit(fwk_id_t id, uint32_t power_limit) } static struct interface_power_management_api thermal_power_estimator_api = { - .get_limit = thermal_power_estimator_get_limit, - .set_limit = thermal_power_estimator_set_limit, + .get_power_limit = thermal_power_estimator_get_limit, + .set_power_limit = thermal_power_estimator_set_limit, }; /* -- GitLab From 77ca6fa0a6d1aa02208f66571801d928125509d9 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Tue, 5 Nov 2024 14:54:50 +0000 Subject: [PATCH 2/8] interface/power_management: Add set power demand API Add an API to set power demand for an entity in the system via the generic fwk id. This API should be implemented in components that care for the power demand of an entity. And API should be called by components that want to communicate the information of the power demand to those components mentioned earlier. Signed-off-by: Mohamed Omar Asaker --- .../power_management/interface_power_management.h | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/interface/power_management/interface_power_management.h b/interface/power_management/interface_power_management.h index cdea316f2..9faf4c4ca 100644 --- a/interface/power_management/interface_power_management.h +++ b/interface/power_management/interface_power_management.h @@ -69,6 +69,16 @@ struct interface_power_management_api { * \retval One of the standard framework status codes. */ int (*set_power_limit)(fwk_id_t id, uint32_t power_limit); + /*! + * \brief Set the power demand for an entity to be registered. This doesn't + * necessarily mean the power demand is satisfied physically. + * \param id Identifier of the entity to set the limit to. + * \param power_demand The power demand asked for the entity. + * + * \retval ::FWK_SUCCESS The power demand is set successfully + * \retval One of the standard framework status codes. + */ + int (*set_power_demand)(fwk_id_t id, uint32_t power_demand); }; /*! -- GitLab From 630c605a75439483d7b23c4c360143822340b9c2 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Wed, 20 Nov 2024 16:46:42 +0000 Subject: [PATCH 3/8] mod/power-distributor: Add initial module Introduce initial power distributor module, which includes: - The basic fwk handlers - Configuration definitions - APIs - Module and domain runtime data (context) Signed-off-by: Mohamed Omar Asaker --- module/CMakeLists.txt | 1 + module/power_distributor/CMakeLists.txt | 17 ++ module/power_distributor/Module.cmake | 9 + .../include/mod_power_distributor.h | 90 ++++++++++ .../src/mod_power_distributor.c | 168 ++++++++++++++++++ 5 files changed, 285 insertions(+) create mode 100644 module/power_distributor/CMakeLists.txt create mode 100644 module/power_distributor/Module.cmake create mode 100644 module/power_distributor/include/mod_power_distributor.h create mode 100644 module/power_distributor/src/mod_power_distributor.c diff --git a/module/CMakeLists.txt b/module/CMakeLists.txt index b3b29e44c..992725351 100644 --- a/module/CMakeLists.txt +++ b/module/CMakeLists.txt @@ -61,6 +61,7 @@ list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pid_controller") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pik_clock") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pl011") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/power_capping") +list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/power_distributor") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/power_domain") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/ppu_v0") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/ppu_v1") diff --git a/module/power_distributor/CMakeLists.txt b/module/power_distributor/CMakeLists.txt new file mode 100644 index 000000000..b72f02be1 --- /dev/null +++ b/module/power_distributor/CMakeLists.txt @@ -0,0 +1,17 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +add_library(${SCP_MODULE_TARGET} SCP_MODULE) + +target_include_directories(${SCP_MODULE_TARGET} + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") + +target_include_directories(${SCP_MODULE_TARGET} + PUBLIC "${CMAKE_SOURCE_DIR}/interface/power_management") + +target_sources(${SCP_MODULE_TARGET} + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_power_distributor.c") diff --git a/module/power_distributor/Module.cmake b/module/power_distributor/Module.cmake new file mode 100644 index 000000000..7120723a5 --- /dev/null +++ b/module/power_distributor/Module.cmake @@ -0,0 +1,9 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +set(SCP_MODULE "power-distributor") +set(SCP_MODULE_TARGET "module-power-distributor") diff --git a/module/power_distributor/include/mod_power_distributor.h b/module/power_distributor/include/mod_power_distributor.h new file mode 100644 index 000000000..3788eab43 --- /dev/null +++ b/module/power_distributor/include/mod_power_distributor.h @@ -0,0 +1,90 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Description: + * Power Distributor + */ + +#ifndef MOD_POWER_DISTRIBUTOR_H +#define MOD_POWER_DISTRIBUTOR_H + +#include + +/*! + * \addtogroup GroupModules Modules + * \{ + */ + +/*! + * \defgroup GroupPowerDistributor Power Budget Distributor + * \{ + */ + +/*! + * \brief API indices + */ +enum mod_power_distributor_api_idx { + /*! Power Distributor API distribution idx */ + MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION, + /*! Power Distributor API count */ + MOD_POWER_DISTRIBUTOR_API_IDX_COUNT, +}; + +/*! + * \brief Power Distributor API + * + * \details Interface implements distribution functionality all domains. + */ +struct mod_power_distributor_api { + /*! + * \brief Distribute Power Budgets + * + * By calling this API, Distributor distributes power budgets + * from the ultimate root of the system. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::One of the standard framework status codes. + */ + int (*system_power_distribute)(void); + /*! + * \brief Distribute Power Budgets given a root domain of a subtree + * + * By calling this API, Distributor distributes power budgets + * from the given domain all the way down to the leaves. + * \param subtree_root_id Identifier of the domain to start distribution + * from. + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::One of the standard framework status codes. + */ + int (*subtree_power_distribute)(fwk_id_t subtree_root_id); +}; + +/*! + * \brief Power Distributor domain configuration data. + */ +struct mod_power_distibutor_domain_config { + /*! The parent domain index */ + uint32_t parent_idx; + /*! Controller ID associated with the domain to apply the power budget. */ + fwk_optional_id_t controller_id; + /*! + * \brief Domain controller API ID + * + * \details The ID is only required when the domain + * has a controller that make use of the power budget. + */ + fwk_optional_id_t controller_api_id; +}; + +/*! + * \} + */ + +/*! + * \} + */ + +#endif /* MOD_POWER_DISTRIBUTOR_H */ diff --git a/module/power_distributor/src/mod_power_distributor.c b/module/power_distributor/src/mod_power_distributor.c new file mode 100644 index 000000000..6b0229f16 --- /dev/null +++ b/module/power_distributor/src/mod_power_distributor.c @@ -0,0 +1,168 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Description: + * Power Distributor + */ + +#include "mod_power_distributor.h" + +#include + +#include +#include +#include +#include +#include + +struct mod_power_distributor_data { + uint32_t power_demand; + uint32_t power_budget; + uint32_t power_limit; +}; + +struct mod_power_distributor_node { + struct mod_power_distributor_data data; + size_t *children_idx_table; + size_t children_count; +}; + +struct mod_power_distributor_domain_ctx { + struct mod_power_distributor_node node; + struct interface_power_management_api *controller_api; + struct mod_power_distibutor_domain_config *config; +}; + +struct mod_power_distributor_ctx { + /* list of system domains context */ + struct mod_power_distributor_domain_ctx *domain; + /* Number of domains */ + size_t domain_count; +}; + +static struct mod_power_distributor_ctx power_distributor_ctx; + +static int subtree_power_distribute(fwk_id_t subtree_root_id); +static int system_power_distribute(void); + +static struct mod_power_distributor_api distribution_api = { + .subtree_power_distribute = subtree_power_distribute, + .system_power_distribute = system_power_distribute, +}; + +static inline struct mod_power_distributor_domain_ctx *get_domain_ctx( + size_t idx) +{ + return &power_distributor_ctx.domain[idx]; +} + +static int subtree_power_distribute(fwk_id_t subtree_root_id) +{ + return FWK_SUCCESS; +} + +static int system_power_distribute(void) +{ + return FWK_SUCCESS; +} + +/* + * Framework handlers + */ + +static int power_distributor_init( + fwk_id_t module_id, + unsigned int element_count, + const void *config_data) +{ + if (element_count == 0U || + !fwk_id_is_equal( + module_id, FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DISTRIBUTOR))) { + return FWK_E_PARAM; + } + + power_distributor_ctx.domain_count = element_count; + power_distributor_ctx.domain = + fwk_mm_calloc(element_count, sizeof(power_distributor_ctx.domain[0])); + + return FWK_SUCCESS; +} + +static int power_distributor_element_init( + fwk_id_t element_id, + unsigned int sub_element_count, + const void *data) +{ + struct mod_power_distributor_domain_ctx *domain_ctx = + get_domain_ctx(fwk_id_get_element_idx(element_id)); + + domain_ctx->node.data.power_demand = 0; + domain_ctx->node.data.power_limit = NO_POWER_LIMIT; + domain_ctx->node.data.power_budget = 0; + domain_ctx->controller_api = NULL; + domain_ctx->config = (struct mod_power_distibutor_domain_config *)data; + domain_ctx->node.children_idx_table = NULL; + domain_ctx->node.children_count = 0; + + return FWK_SUCCESS; +} + +static int power_distributor_bind(fwk_id_t id, unsigned int round) +{ + /* bind only elements and only in round 0 */ + if (round != 0 || !fwk_id_is_type(id, FWK_ID_TYPE_ELEMENT)) { + return FWK_SUCCESS; + } + + int status = FWK_SUCCESS; + struct mod_power_distributor_domain_ctx *domain_ctx = + get_domain_ctx(fwk_id_get_element_idx(id)); + + if (fwk_optional_id_is_defined(domain_ctx->config->controller_api_id) && + !fwk_id_is_equal(domain_ctx->config->controller_api_id, FWK_ID_NONE)) { + status = fwk_module_bind( + fwk_id_build_module_id(domain_ctx->config->controller_api_id), + domain_ctx->config->controller_api_id, + &domain_ctx->controller_api); + } + + return status; +} + +static int power_distributor_process_bind_request( + fwk_id_t source_id, + fwk_id_t target_id, + fwk_id_t api_id, + const void **api) +{ + if (!fwk_id_is_equal( + api_id, + FWK_ID_API( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION))) { + return FWK_E_PARAM; + } + + *api = &distribution_api; + + return FWK_SUCCESS; +} + +static int power_distributor_start(fwk_id_t id) +{ + return FWK_SUCCESS; +} + +/* power_distributor module definition */ +const struct fwk_module module_power_distributor = { + .type = FWK_MODULE_TYPE_SERVICE, + .api_count = MOD_POWER_DISTRIBUTOR_API_IDX_COUNT, + .init = power_distributor_init, + .element_init = power_distributor_element_init, + .bind = power_distributor_bind, + .start = power_distributor_start, + .process_bind_request = power_distributor_process_bind_request, +}; -- GitLab From de0c1f3a4e356d09d0025e0f2854017077509231 Mon Sep 17 00:00:00 2001 From: Matthew Wellings Date: Mon, 9 Dec 2024 08:21:32 +0000 Subject: [PATCH 4/8] mod/power-distributor: Add initial tests for module Add first (init & bind) tests for the power-distributor module. Signed-off-by: Matthew Wellings --- module/power_distributor/test/CMakeLists.txt | 29 +++ .../test/config_power_distributor.h | 62 ++++++ .../power_distributor/test/fwk_module_idx.h | 21 ++ .../test/mod_power_distributor_unit_test.c | 206 ++++++++++++++++++ unit_test/CMakeLists.txt | 1 + 5 files changed, 319 insertions(+) create mode 100644 module/power_distributor/test/CMakeLists.txt create mode 100644 module/power_distributor/test/config_power_distributor.h create mode 100644 module/power_distributor/test/fwk_module_idx.h create mode 100644 module/power_distributor/test/mod_power_distributor_unit_test.c diff --git a/module/power_distributor/test/CMakeLists.txt b/module/power_distributor/test/CMakeLists.txt new file mode 100644 index 000000000..f199f5b77 --- /dev/null +++ b/module/power_distributor/test/CMakeLists.txt @@ -0,0 +1,29 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +set(TEST_SRC mod_power_distributor) +set(TEST_FILE mod_power_distributor) + +if(TEST_ON_TARGET) + set(TEST_MODULE power_distributor) + set(MODULE_ROOT ${CMAKE_SOURCE_DIR}/module) +else() + set(UNIT_TEST_TARGET mod_${TEST_MODULE}_unit_test) +endif() + +set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src) +set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include) +set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_INC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_MOCK_SRC ${CMAKE_CURRENT_LIST_DIR}/mocks) + +list(APPEND MOCK_REPLACEMENTS fwk_mm) +list(APPEND MOCK_REPLACEMENTS fwk_module) + +list(APPEND OTHER_MODULE_INC ${SCP_ROOT}/interface/power_management) + +include(${SCP_ROOT}/unit_test/module_common.cmake) diff --git a/module/power_distributor/test/config_power_distributor.h b/module/power_distributor/test/config_power_distributor.h new file mode 100644 index 000000000..352f0ad5c --- /dev/null +++ b/module/power_distributor/test/config_power_distributor.h @@ -0,0 +1,62 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include +#include +#include + +enum test_power_distributor_domain_idx { + TEST_DOMAIN_SOC, + TEST_DOMAIN_CPU, + TEST_DOMAIN_CPU_BIG, + TEST_DOMAIN_CPU_LITTLE, + TEST_DOMAIN_GPU, + TEST_DOMAIN_COUNT, + TEST_DOMAIN_NONE = UINT32_MAX, +}; + +enum test_power_controller_api_idx { + TEST_CONTROLLER_API_SOC, + TEST_CONTROLLER_API_CPU, + TEST_CONTROLLER_API_CPU_BIG, + TEST_CONTROLLER_API_CPU_LITTLE, + TEST_CONTROLLER_API_GPU, + TEST_CONTROLLER_API_COUNT, +}; + +struct mod_power_distibutor_domain_config test_power_distibutor_domain_config[TEST_DOMAIN_COUNT] = { + [TEST_DOMAIN_SOC] = { + .parent_idx = TEST_DOMAIN_NONE, + .controller_api_id = FWK_ID_API_INIT( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + TEST_CONTROLLER_API_SOC), + }, + [TEST_DOMAIN_CPU] = { + .parent_idx = TEST_DOMAIN_SOC, + .controller_api_id = FWK_ID_NONE, + }, + [TEST_DOMAIN_CPU_BIG] = { + .parent_idx = TEST_DOMAIN_CPU, + .controller_api_id = FWK_ID_API_INIT( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + TEST_CONTROLLER_API_CPU_BIG), + }, + [TEST_DOMAIN_CPU_LITTLE] = { + .parent_idx = TEST_DOMAIN_CPU, + .controller_api_id = FWK_ID_API_INIT( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + TEST_CONTROLLER_API_CPU_LITTLE), + }, + [TEST_DOMAIN_GPU] = { + .parent_idx = TEST_DOMAIN_SOC, + .controller_api_id = FWK_ID_API_INIT( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + TEST_CONTROLLER_API_GPU), + }, +}; diff --git a/module/power_distributor/test/fwk_module_idx.h b/module/power_distributor/test/fwk_module_idx.h new file mode 100644 index 000000000..409c6390a --- /dev/null +++ b/module/power_distributor/test/fwk_module_idx.h @@ -0,0 +1,21 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef TEST_FWK_MODULE_MODULE_IDX_H +#define TEST_FWK_MODULE_MODULE_IDX_H + +#include + +enum fwk_module_idx { + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + FWK_MODULE_IDX_COUNT, +}; + +static const fwk_id_t fwk_module_id_power_distributor = + FWK_ID_MODULE_INIT(FWK_MODULE_IDX_POWER_DISTRIBUTOR); + +#endif /* TEST_FWK_MODULE_MODULE_IDX_H */ diff --git a/module/power_distributor/test/mod_power_distributor_unit_test.c b/module/power_distributor/test/mod_power_distributor_unit_test.c new file mode 100644 index 000000000..ae262d559 --- /dev/null +++ b/module/power_distributor/test/mod_power_distributor_unit_test.c @@ -0,0 +1,206 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Description: + * Power capping module unit test. + */ + +#include "config_power_distributor.h" +#include "scp_unity.h" +#include "unity.h" + +#include +#include + +#include + +#include UNIT_TEST_SRC + +struct mod_power_distributor_domain_ctx test_ctx_table[TEST_DOMAIN_COUNT]; + +struct interface_power_management_api test_power_management_api = { 0 }; + +void setUp(void) +{ + memset((void *)test_ctx_table, 0U, sizeof(test_ctx_table)); + power_distributor_ctx.domain = test_ctx_table; + + power_distributor_ctx.domain_count = TEST_DOMAIN_COUNT; + for (unsigned int i = 0U; i < TEST_DOMAIN_COUNT; i++) { + power_distributor_ctx.domain[i].controller_api = + &test_power_management_api; + power_distributor_ctx.domain[i].config = + &test_power_distibutor_domain_config[i]; + } +} + +void utest_power_distributor_init_success(void) +{ + int status; + unsigned int element_count = 23U; + struct mod_power_distributor_domain_ctx domain = { 0 }; + power_distributor_ctx.domain_count = 0; + + fwk_mm_calloc_ExpectAndReturn( + element_count, sizeof(power_distributor_ctx.domain[0]), &domain); + + status = power_distributor_init( + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DISTRIBUTOR), element_count, NULL); + TEST_ASSERT_EQUAL(element_count, power_distributor_ctx.domain_count); + TEST_ASSERT_EQUAL(&domain, power_distributor_ctx.domain); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_power_distributor_element_init_success(void) +{ + int status; + fwk_id_t element_id; + static struct mod_power_distibutor_domain_config + domains_config[TEST_DOMAIN_COUNT] = { 0 }; + + for (unsigned int index = 0U; index < TEST_DOMAIN_COUNT; index++) { + element_id = FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DISTRIBUTOR, index); + + status = power_distributor_element_init( + element_id, 30U, &domains_config[index]); + + TEST_ASSERT_EQUAL_PTR( + &domains_config[index], power_distributor_ctx.domain[index].config); + TEST_ASSERT_EQUAL_PTR( + NULL, power_distributor_ctx.domain[index].controller_api); + TEST_ASSERT_EQUAL_PTR( + NULL, power_distributor_ctx.domain[index].node.children_idx_table); + TEST_ASSERT_EQUAL( + 0, power_distributor_ctx.domain[index].node.children_count); + TEST_ASSERT_EQUAL( + 0, power_distributor_ctx.domain[index].node.data.power_demand); + TEST_ASSERT_EQUAL( + 0, power_distributor_ctx.domain[index].node.data.power_budget); + TEST_ASSERT_EQUAL( + NO_POWER_LIMIT, + power_distributor_ctx.domain[index].node.data.power_limit); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + } +} + +void utest_mod_distributor_bind_round_0(void) +{ + int status; + unsigned int round = 0U; + + for (unsigned int index = 0U; index < TEST_DOMAIN_COUNT; index++) { + fwk_id_t domain_id = + FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_DISTRIBUTOR, index); + struct mod_power_distributor_domain_ctx *domain_ctx = + &(power_distributor_ctx.domain[index]); + + if (!fwk_id_is_equal( + domain_ctx->config->controller_api_id, FWK_ID_NONE)) { + fwk_module_bind_ExpectAndReturn( + fwk_id_build_module_id(domain_ctx->config->controller_api_id), + domain_ctx->config->controller_api_id, + &domain_ctx->controller_api, + FWK_SUCCESS); + } + + status = power_distributor_bind(domain_id, round); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + } +} + +void utest_mod_distributor_bind_invalid_round(void) +{ + int status; + unsigned int round = 1U; + + for (unsigned int index = 0U; index < TEST_DOMAIN_COUNT; index++) { + fwk_id_t domain_id = + FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_DISTRIBUTOR, index); + + status = power_distributor_bind(domain_id, round); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + } +} + +void utest_mod_distributor_process_bind_request(void) +{ + int status; + fwk_id_t dummy_id = FWK_ID_NONE; + const void *api = NULL; + + status = power_distributor_process_bind_request( + dummy_id, + dummy_id, + FWK_ID_API( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, + MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION), + &api); + + TEST_ASSERT_EQUAL_PTR(&distribution_api, api); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_mod_distributor_process_bind_request_invalid_api(void) +{ + int status; + fwk_id_t dummy_id = FWK_ID_NONE; + enum mod_power_distributor_api_idx invalid_api_id = + MOD_POWER_DISTRIBUTOR_API_IDX_COUNT; + const void *api = NULL; + + status = power_distributor_process_bind_request( + dummy_id, + dummy_id, + FWK_ID_API(FWK_MODULE_IDX_POWER_DISTRIBUTOR, invalid_api_id), + &api); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_mod_distributor_process_bind_request_invalid_module(void) +{ + int status; + fwk_id_t dummy_id = FWK_ID_NONE; + enum fwk_module_idx invalid_module_idx = FWK_MODULE_IDX_COUNT; + const void *api = NULL; + + status = power_distributor_process_bind_request( + dummy_id, + dummy_id, + FWK_ID_API( + invalid_module_idx, MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION), + &api); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void tearDown(void) +{ +} + +int power_distributor_test_main(void) +{ + UNITY_BEGIN(); + + RUN_TEST(utest_power_distributor_init_success); + RUN_TEST(utest_power_distributor_element_init_success); + RUN_TEST(utest_mod_distributor_bind_round_0); + RUN_TEST(utest_mod_distributor_bind_invalid_round); + RUN_TEST(utest_mod_distributor_process_bind_request); + RUN_TEST(utest_mod_distributor_process_bind_request_invalid_api); + RUN_TEST(utest_mod_distributor_process_bind_request_invalid_module); + + return UNITY_END(); +} + +#if !defined(TEST_ON_TARGET) +int main(void) +{ + return power_distributor_test_main(); +} +#endif diff --git a/unit_test/CMakeLists.txt b/unit_test/CMakeLists.txt index c49b96092..0d7e546b5 100644 --- a/unit_test/CMakeLists.txt +++ b/unit_test/CMakeLists.txt @@ -123,6 +123,7 @@ list(APPEND UNIT_MODULE mpmm_v2) list(APPEND UNIT_MODULE perf_controller) list(APPEND UNIT_MODULE pid_controller) list(APPEND UNIT_MODULE pl011) +list(APPEND UNIT_MODULE power_distributor) list(APPEND UNIT_MODULE power_domain) list(APPEND UNIT_MODULE ppu_v1) list(APPEND UNIT_MODULE resource_perms) -- GitLab From bba49911664bf66286ad31540b6a11ec7b456462 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Tue, 3 Dec 2024 18:00:16 +0000 Subject: [PATCH 5/8] mod/power_distributor: Add tree construction After elements initialization, tree construction is possible. Hence, use the post_init framework handler to construct the tree. The tree is index based table, each domain has children index table. Covered by a simple unit test. Signed-off-by: Mohamed Omar Asaker --- .../src/mod_power_distributor.c | 57 ++++++++++++++++++ .../test/mod_power_distributor_unit_test.c | 60 +++++++++++++++++++ 2 files changed, 117 insertions(+) diff --git a/module/power_distributor/src/mod_power_distributor.c b/module/power_distributor/src/mod_power_distributor.c index 6b0229f16..9647970d0 100644 --- a/module/power_distributor/src/mod_power_distributor.c +++ b/module/power_distributor/src/mod_power_distributor.c @@ -59,6 +59,53 @@ static inline struct mod_power_distributor_domain_ctx *get_domain_ctx( return &power_distributor_ctx.domain[idx]; } +static inline bool domain_has_parent( + struct mod_power_distributor_domain_ctx *domain_ctx) +{ + return domain_ctx->config->parent_idx < power_distributor_ctx.domain_count; +} + +static inline void calculate_children_count(void) +{ + for (size_t i = 0; i < power_distributor_ctx.domain_count; i++) { + struct mod_power_distributor_domain_ctx *domain_ctx = get_domain_ctx(i); + if (domain_has_parent(domain_ctx)) { + ++power_distributor_ctx.domain[domain_ctx->config->parent_idx] + .node.children_count; + } + } +} + +static inline void allocate_children_table(void) +{ + for (size_t i = 0; i < power_distributor_ctx.domain_count; i++) { + struct mod_power_distributor_domain_ctx *domain_ctx = get_domain_ctx(i); + if (domain_ctx->node.children_count > 0) { + domain_ctx->node.children_idx_table = fwk_mm_calloc( + domain_ctx->node.children_count, + sizeof(domain_ctx->node.children_idx_table[0])); + } + } +} + +static inline void set_domain_relations(void) +{ + for (size_t i = 0; i < power_distributor_ctx.domain_count; i++) { + struct mod_power_distributor_domain_ctx *domain_ctx = get_domain_ctx(i); + domain_ctx->node.children_count = 0; + } + + for (size_t i = 0; i < power_distributor_ctx.domain_count; i++) { + struct mod_power_distributor_domain_ctx *domain_ctx = get_domain_ctx(i); + if (domain_has_parent(domain_ctx)) { + struct mod_power_distributor_domain_ctx *parent_ctx = + get_domain_ctx(domain_ctx->config->parent_idx); + parent_ctx->node + .children_idx_table[parent_ctx->node.children_count++] = i; + } + } +} + static int subtree_power_distribute(fwk_id_t subtree_root_id) { return FWK_SUCCESS; @@ -110,6 +157,15 @@ static int power_distributor_element_init( return FWK_SUCCESS; } +static int power_distributor_post_init(fwk_id_t module_id) +{ + calculate_children_count(); + allocate_children_table(); + set_domain_relations(); + + return FWK_SUCCESS; +} + static int power_distributor_bind(fwk_id_t id, unsigned int round) { /* bind only elements and only in round 0 */ @@ -162,6 +218,7 @@ const struct fwk_module module_power_distributor = { .api_count = MOD_POWER_DISTRIBUTOR_API_IDX_COUNT, .init = power_distributor_init, .element_init = power_distributor_element_init, + .post_init = power_distributor_post_init, .bind = power_distributor_bind, .start = power_distributor_start, .process_bind_request = power_distributor_process_bind_request, diff --git a/module/power_distributor/test/mod_power_distributor_unit_test.c b/module/power_distributor/test/mod_power_distributor_unit_test.c index ae262d559..ec8d69bed 100644 --- a/module/power_distributor/test/mod_power_distributor_unit_test.c +++ b/module/power_distributor/test/mod_power_distributor_unit_test.c @@ -179,6 +179,65 @@ void utest_mod_distributor_process_bind_request_invalid_module(void) TEST_ASSERT_EQUAL(FWK_E_PARAM, status); } +void utest_mod_distributor_post_init_success(void) +{ + int status = FWK_E_DATA; + struct mod_power_distibutor_domain_config config[TEST_DOMAIN_COUNT] = { + [TEST_DOMAIN_SOC] = { .parent_idx = TEST_DOMAIN_NONE,}, + [TEST_DOMAIN_CPU] = { .parent_idx = TEST_DOMAIN_SOC, }, + [TEST_DOMAIN_GPU] = { .parent_idx = TEST_DOMAIN_SOC, }, + [TEST_DOMAIN_CPU_BIG] = { .parent_idx = TEST_DOMAIN_CPU, }, + [TEST_DOMAIN_CPU_LITTLE] = { .parent_idx = TEST_DOMAIN_CPU, }, + }; + size_t children_of_soc[2]; + size_t children_of_cpu[2]; + power_distributor_ctx.domain_count = TEST_DOMAIN_COUNT; + + for (size_t i = 0; i < TEST_DOMAIN_COUNT; ++i) { + power_distributor_ctx.domain[i].config = &config[i]; + } + + fwk_mm_calloc_ExpectAndReturn( + 2, sizeof(children_of_soc[0]), &children_of_soc); + fwk_mm_calloc_ExpectAndReturn( + 2, sizeof(children_of_cpu[0]), &children_of_cpu); + + status = power_distributor_post_init( + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DISTRIBUTOR)); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL_PTR( + &children_of_soc, + power_distributor_ctx.domain[TEST_DOMAIN_SOC].node.children_idx_table); + TEST_ASSERT_EQUAL( + 2, power_distributor_ctx.domain[TEST_DOMAIN_SOC].node.children_count); + TEST_ASSERT_EQUAL_PTR( + &children_of_cpu, + power_distributor_ctx.domain[TEST_DOMAIN_CPU].node.children_idx_table); + TEST_ASSERT_EQUAL( + 2, power_distributor_ctx.domain[TEST_DOMAIN_CPU].node.children_count); + TEST_ASSERT_EQUAL_PTR( + NULL, + power_distributor_ctx.domain[TEST_DOMAIN_GPU].node.children_idx_table); + TEST_ASSERT_EQUAL( + 0, power_distributor_ctx.domain[TEST_DOMAIN_GPU].node.children_count); + TEST_ASSERT_EQUAL_PTR( + NULL, + power_distributor_ctx.domain[TEST_DOMAIN_CPU_BIG] + .node.children_idx_table); + TEST_ASSERT_EQUAL( + 0, + power_distributor_ctx.domain[TEST_DOMAIN_CPU_BIG].node.children_count); + TEST_ASSERT_EQUAL_PTR( + NULL, + power_distributor_ctx.domain[TEST_DOMAIN_CPU_LITTLE] + .node.children_idx_table); + TEST_ASSERT_EQUAL( + 0, + power_distributor_ctx.domain[TEST_DOMAIN_CPU_LITTLE] + .node.children_count); +} + void tearDown(void) { } @@ -194,6 +253,7 @@ int power_distributor_test_main(void) RUN_TEST(utest_mod_distributor_process_bind_request); RUN_TEST(utest_mod_distributor_process_bind_request_invalid_api); RUN_TEST(utest_mod_distributor_process_bind_request_invalid_module); + RUN_TEST(utest_mod_distributor_post_init_success); return UNITY_END(); } -- GitLab From 79aeb16ae1db914f22d00db877dfa9656f249fa6 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Tue, 26 Nov 2024 23:24:34 +0000 Subject: [PATCH 6/8] mod/power_distributor: Add implementation of PM interface Add implementation of the power management interface API: - set_power_limit - set_power_demand Covered by unit test. Signed-off-by: Mohamed Omar Asaker --- .../include/mod_power_distributor.h | 2 + .../src/mod_power_distributor.c | 58 +++++++++++++++++-- .../test/mod_power_distributor_unit_test.c | 44 ++++++++++++++ 3 files changed, 98 insertions(+), 6 deletions(-) diff --git a/module/power_distributor/include/mod_power_distributor.h b/module/power_distributor/include/mod_power_distributor.h index 3788eab43..16b8f7e10 100644 --- a/module/power_distributor/include/mod_power_distributor.h +++ b/module/power_distributor/include/mod_power_distributor.h @@ -29,6 +29,8 @@ enum mod_power_distributor_api_idx { /*! Power Distributor API distribution idx */ MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION, + /*! Power Distributor API power management idx */ + MOD_POWER_DISTRIBUTOR_API_IDX_POWER_MANAGEMENT, /*! Power Distributor API count */ MOD_POWER_DISTRIBUTOR_API_IDX_COUNT, }; diff --git a/module/power_distributor/src/mod_power_distributor.c b/module/power_distributor/src/mod_power_distributor.c index 9647970d0..835ba0524 100644 --- a/module/power_distributor/src/mod_power_distributor.c +++ b/module/power_distributor/src/mod_power_distributor.c @@ -47,12 +47,19 @@ static struct mod_power_distributor_ctx power_distributor_ctx; static int subtree_power_distribute(fwk_id_t subtree_root_id); static int system_power_distribute(void); +static int set_power_limit(fwk_id_t id, uint32_t power_limit); +static int set_power_demand(fwk_id_t id, uint32_t power_demand); static struct mod_power_distributor_api distribution_api = { .subtree_power_distribute = subtree_power_distribute, .system_power_distribute = system_power_distribute, }; +struct interface_power_management_api power_management_api = { + .set_power_demand = set_power_demand, + .set_power_limit = set_power_limit, +}; + static inline struct mod_power_distributor_domain_ctx *get_domain_ctx( size_t idx) { @@ -106,6 +113,12 @@ static inline void set_domain_relations(void) } } +static inline bool is_element_id_valid(fwk_id_t id) +{ + return fwk_id_get_module_idx(id) == FWK_MODULE_IDX_POWER_DISTRIBUTOR && + fwk_id_get_element_idx(id) < power_distributor_ctx.domain_count; +} + static int subtree_power_distribute(fwk_id_t subtree_root_id) { return FWK_SUCCESS; @@ -116,6 +129,30 @@ static int system_power_distribute(void) return FWK_SUCCESS; } +int set_power_limit(fwk_id_t id, uint32_t power_limit) +{ + if (!is_element_id_valid(id)) { + return FWK_E_PARAM; + } + + struct mod_power_distributor_domain_ctx *domain_ctx = + &power_distributor_ctx.domain[fwk_id_get_element_idx(id)]; + domain_ctx->node.data.power_limit = power_limit; + return FWK_SUCCESS; +} + +int set_power_demand(fwk_id_t id, uint32_t power_demand) +{ + if (!is_element_id_valid(id)) { + return FWK_E_PARAM; + } + + struct mod_power_distributor_domain_ctx *domain_ctx = + &power_distributor_ctx.domain[fwk_id_get_element_idx(id)]; + domain_ctx->node.data.power_demand = power_demand; + return FWK_SUCCESS; +} + /* * Framework handlers */ @@ -194,15 +231,24 @@ static int power_distributor_process_bind_request( fwk_id_t api_id, const void **api) { - if (!fwk_id_is_equal( - api_id, - FWK_ID_API( - FWK_MODULE_IDX_POWER_DISTRIBUTOR, - MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION))) { + if ((enum fwk_module_idx)fwk_id_get_module_idx(api_id) != + FWK_MODULE_IDX_POWER_DISTRIBUTOR) { return FWK_E_PARAM; } - *api = &distribution_api; + enum mod_power_distributor_api_idx api_idx = + (enum mod_power_distributor_api_idx)fwk_id_get_api_idx(api_id); + + switch (api_idx) { + case MOD_POWER_DISTRIBUTOR_API_IDX_DISTRIBUTION: + *api = &distribution_api; + break; + case MOD_POWER_DISTRIBUTOR_API_IDX_POWER_MANAGEMENT: + *api = &power_management_api; + break; + default: + return FWK_E_PARAM; + } return FWK_SUCCESS; } diff --git a/module/power_distributor/test/mod_power_distributor_unit_test.c b/module/power_distributor/test/mod_power_distributor_unit_test.c index ec8d69bed..3d425ffeb 100644 --- a/module/power_distributor/test/mod_power_distributor_unit_test.c +++ b/module/power_distributor/test/mod_power_distributor_unit_test.c @@ -238,6 +238,48 @@ void utest_mod_distributor_post_init_success(void) .node.children_count); } +void utest_mod_distributor_set_power_limit_demand_api_success(void) +{ + int status = FWK_E_DATA; + for (size_t i = 0; i < TEST_DOMAIN_COUNT; ++i) { + fwk_id_t elem_id = FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DISTRIBUTOR, i); + status = set_power_limit(elem_id, i); + TEST_ASSERT_EQUAL( + i, power_distributor_ctx.domain[i].node.data.power_limit); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + status = set_power_demand(elem_id, i); + TEST_ASSERT_EQUAL( + i, power_distributor_ctx.domain[i].node.data.power_demand); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + } +} + +void utest_mod_distributor_set_power_limit_demand_api_invalid_params(void) +{ + int status = FWK_E_DATA; + fwk_id_t invalid_elem_id = + FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DISTRIBUTOR, TEST_DOMAIN_COUNT); + fwk_id_t invalid_elem_id2 = FWK_ID_ELEMENT( + FWK_MODULE_IDX_POWER_DISTRIBUTOR, TEST_DOMAIN_COUNT + 10); + fwk_id_t invalid_module_elem_id = + FWK_ID_ELEMENT(FWK_MODULE_IDX_COUNT, TEST_DOMAIN_CPU); + + status = set_power_limit(invalid_elem_id, 0); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); + status = set_power_demand(invalid_elem_id, 0); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); + + status = set_power_limit(invalid_elem_id2, 0); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); + status = set_power_demand(invalid_elem_id2, 0); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); + + status = set_power_limit(invalid_module_elem_id, 0); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); + status = set_power_demand(invalid_module_elem_id, 0); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + void tearDown(void) { } @@ -254,6 +296,8 @@ int power_distributor_test_main(void) RUN_TEST(utest_mod_distributor_process_bind_request_invalid_api); RUN_TEST(utest_mod_distributor_process_bind_request_invalid_module); RUN_TEST(utest_mod_distributor_post_init_success); + RUN_TEST(utest_mod_distributor_set_power_limit_demand_api_success); + RUN_TEST(utest_mod_distributor_set_power_limit_demand_api_invalid_params); return UNITY_END(); } -- GitLab From 9b352c6b8f632177032d88811a7518e4eada2a75 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Thu, 19 Dec 2024 03:38:30 +0000 Subject: [PATCH 7/8] mod/power_distributor: Add distribution interface implementation Add an initial implementation of the distribution interface. This initial implementation will only passthrough the set power limit to the controller (if the domain has a controller). At this initial stage there will be no support for subtree distribution. The distribution implementation will evolve iteratively. Signed-off-by: Mohamed Omar Asaker --- .../src/mod_power_distributor.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/module/power_distributor/src/mod_power_distributor.c b/module/power_distributor/src/mod_power_distributor.c index 835ba0524..bb784e458 100644 --- a/module/power_distributor/src/mod_power_distributor.c +++ b/module/power_distributor/src/mod_power_distributor.c @@ -121,11 +121,25 @@ static inline bool is_element_id_valid(fwk_id_t id) static int subtree_power_distribute(fwk_id_t subtree_root_id) { - return FWK_SUCCESS; + return FWK_E_SUPPORT; } static int system_power_distribute(void) { + for (size_t i = 0; i < power_distributor_ctx.domain_count; ++i) { + struct mod_power_distributor_domain_ctx *domain_ctx = + &power_distributor_ctx.domain[i]; + if (domain_ctx->controller_api != NULL) { + FWK_LOG_DEBUG( + "Grant power for %s", + fwk_module_get_element_name( + FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DISTRIBUTOR, i))); + domain_ctx->controller_api->set_power_limit( + domain_ctx->config->controller_id, + domain_ctx->node.data.power_limit); + } + } + return FWK_SUCCESS; } -- GitLab From c4ab3c468bf35106fe4dc83cd19200832ade2378 Mon Sep 17 00:00:00 2001 From: Mohamed Omar Asaker Date: Fri, 20 Dec 2024 12:40:23 +0000 Subject: [PATCH 8/8] mod/power-distributor/test: Add a UT for system distribution Adding a unit test for system distribution. The test expects the controller api to be called by the already stored power limit. Therefore, controller power managment interface mocks are added. Signed-off-by: Mohamed Omar Asaker --- .../test/config_power_distributor.h | 15 +- .../power_distributor/test/fwk_module_idx.h | 4 + .../test/mocks/.clang-format | 4 + .../mocks/Mockmod_power_distributor_extra.c | 564 ++++++++++++++++++ .../mocks/Mockmod_power_distributor_extra.h | 88 +++ .../test/mod_power_distributor_extra.h | 20 + .../test/mod_power_distributor_unit_test.c | 51 +- 7 files changed, 737 insertions(+), 9 deletions(-) create mode 100644 module/power_distributor/test/mocks/.clang-format create mode 100644 module/power_distributor/test/mocks/Mockmod_power_distributor_extra.c create mode 100644 module/power_distributor/test/mocks/Mockmod_power_distributor_extra.h create mode 100644 module/power_distributor/test/mod_power_distributor_extra.h diff --git a/module/power_distributor/test/config_power_distributor.h b/module/power_distributor/test/config_power_distributor.h index 352f0ad5c..fa804aea6 100644 --- a/module/power_distributor/test/config_power_distributor.h +++ b/module/power_distributor/test/config_power_distributor.h @@ -34,29 +34,34 @@ struct mod_power_distibutor_domain_config test_power_distibutor_domain_config[TE [TEST_DOMAIN_SOC] = { .parent_idx = TEST_DOMAIN_NONE, .controller_api_id = FWK_ID_API_INIT( - FWK_MODULE_IDX_POWER_DISTRIBUTOR, + FWK_MODULE_IDX_CONTROLLER, TEST_CONTROLLER_API_SOC), }, [TEST_DOMAIN_CPU] = { .parent_idx = TEST_DOMAIN_SOC, - .controller_api_id = FWK_ID_NONE, }, [TEST_DOMAIN_CPU_BIG] = { .parent_idx = TEST_DOMAIN_CPU, + .controller_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_CONTROLLER, + TEST_DOMAIN_CPU_BIG), .controller_api_id = FWK_ID_API_INIT( - FWK_MODULE_IDX_POWER_DISTRIBUTOR, + FWK_MODULE_IDX_CONTROLLER, TEST_CONTROLLER_API_CPU_BIG), }, [TEST_DOMAIN_CPU_LITTLE] = { .parent_idx = TEST_DOMAIN_CPU, + .controller_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_CONTROLLER, + TEST_DOMAIN_CPU_LITTLE), .controller_api_id = FWK_ID_API_INIT( - FWK_MODULE_IDX_POWER_DISTRIBUTOR, + FWK_MODULE_IDX_CONTROLLER, TEST_CONTROLLER_API_CPU_LITTLE), }, [TEST_DOMAIN_GPU] = { .parent_idx = TEST_DOMAIN_SOC, + .controller_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_CONTROLLER, + TEST_DOMAIN_GPU), .controller_api_id = FWK_ID_API_INIT( - FWK_MODULE_IDX_POWER_DISTRIBUTOR, + FWK_MODULE_IDX_CONTROLLER, TEST_CONTROLLER_API_GPU), }, }; diff --git a/module/power_distributor/test/fwk_module_idx.h b/module/power_distributor/test/fwk_module_idx.h index 409c6390a..cefcff5c0 100644 --- a/module/power_distributor/test/fwk_module_idx.h +++ b/module/power_distributor/test/fwk_module_idx.h @@ -12,10 +12,14 @@ enum fwk_module_idx { FWK_MODULE_IDX_POWER_DISTRIBUTOR, + FWK_MODULE_IDX_CONTROLLER, FWK_MODULE_IDX_COUNT, }; static const fwk_id_t fwk_module_id_power_distributor = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_POWER_DISTRIBUTOR); +static const fwk_id_t fwk_module_id_controller = + FWK_ID_MODULE_INIT(FWK_MODULE_IDX_CONTROLLER); + #endif /* TEST_FWK_MODULE_MODULE_IDX_H */ diff --git a/module/power_distributor/test/mocks/.clang-format b/module/power_distributor/test/mocks/.clang-format new file mode 100644 index 000000000..eeca2395f --- /dev/null +++ b/module/power_distributor/test/mocks/.clang-format @@ -0,0 +1,4 @@ +{ + "DisableFormat": true, + "SortIncludes": false, +} diff --git a/module/power_distributor/test/mocks/Mockmod_power_distributor_extra.c b/module/power_distributor/test/mocks/Mockmod_power_distributor_extra.c new file mode 100644 index 000000000..1a8288426 --- /dev/null +++ b/module/power_distributor/test/mocks/Mockmod_power_distributor_extra.c @@ -0,0 +1,564 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#include +#include +#include +#include "cmock.h" +#include "Mockmod_power_distributor_extra.h" + +static const char* CMockString_id = "id"; +static const char* CMockString_mock_get_power_limit = "mock_get_power_limit"; +static const char* CMockString_mock_set_power_demand = "mock_set_power_demand"; +static const char* CMockString_mock_set_power_limit = "mock_set_power_limit"; +static const char* CMockString_power_demand = "power_demand"; +static const char* CMockString_power_limit = "power_limit"; + +typedef struct _CMOCK_mock_get_power_limit_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_power_limit; + int Expected_power_limit_Depth; + char ReturnThruPtr_power_limit_Used; + uint32_t* ReturnThruPtr_power_limit_Val; + size_t ReturnThruPtr_power_limit_Size; + char IgnoreArg_id; + char IgnoreArg_power_limit; + +} CMOCK_mock_get_power_limit_CALL_INSTANCE; + +typedef struct _CMOCK_mock_set_power_limit_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t Expected_power_limit; + char IgnoreArg_id; + char IgnoreArg_power_limit; + +} CMOCK_mock_set_power_limit_CALL_INSTANCE; + +typedef struct _CMOCK_mock_set_power_demand_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t Expected_power_demand; + char IgnoreArg_id; + char IgnoreArg_power_demand; + +} CMOCK_mock_set_power_demand_CALL_INSTANCE; + +static struct Mockmod_power_distributor_extraInstance +{ + char mock_get_power_limit_IgnoreBool; + int mock_get_power_limit_FinalReturn; + char mock_get_power_limit_CallbackBool; + CMOCK_mock_get_power_limit_CALLBACK mock_get_power_limit_CallbackFunctionPointer; + int mock_get_power_limit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE mock_get_power_limit_CallInstance; + char mock_set_power_limit_IgnoreBool; + int mock_set_power_limit_FinalReturn; + char mock_set_power_limit_CallbackBool; + CMOCK_mock_set_power_limit_CALLBACK mock_set_power_limit_CallbackFunctionPointer; + int mock_set_power_limit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE mock_set_power_limit_CallInstance; + char mock_set_power_demand_IgnoreBool; + int mock_set_power_demand_FinalReturn; + char mock_set_power_demand_CallbackBool; + CMOCK_mock_set_power_demand_CALLBACK mock_set_power_demand_CallbackFunctionPointer; + int mock_set_power_demand_CallbackCalls; + CMOCK_MEM_INDEX_TYPE mock_set_power_demand_CallInstance; +} Mock; + +extern jmp_buf AbortFrame; + +void Mockmod_power_distributor_extra_Verify(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_MEM_INDEX_TYPE call_instance; + call_instance = Mock.mock_get_power_limit_CallInstance; + if (Mock.mock_get_power_limit_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_mock_get_power_limit); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.mock_get_power_limit_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.mock_set_power_limit_CallInstance; + if (Mock.mock_set_power_limit_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_mock_set_power_limit); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.mock_set_power_limit_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.mock_set_power_demand_CallInstance; + if (Mock.mock_set_power_demand_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_mock_set_power_demand); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.mock_set_power_demand_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } +} + +void Mockmod_power_distributor_extra_Init(void) +{ + Mockmod_power_distributor_extra_Destroy(); +} + +void Mockmod_power_distributor_extra_Destroy(void) +{ + CMock_Guts_MemFreeAll(); + memset(&Mock, 0, sizeof(Mock)); +} + +int mock_get_power_limit(fwk_id_t id, uint32_t* power_limit) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_mock_get_power_limit); + cmock_call_instance = (CMOCK_mock_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.mock_get_power_limit_CallInstance); + Mock.mock_get_power_limit_CallInstance = CMock_Guts_MemNext(Mock.mock_get_power_limit_CallInstance); + if (Mock.mock_get_power_limit_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.mock_get_power_limit_FinalReturn; + Mock.mock_get_power_limit_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.mock_get_power_limit_CallbackBool && + Mock.mock_get_power_limit_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.mock_get_power_limit_CallbackFunctionPointer(id, power_limit, Mock.mock_get_power_limit_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_mock_get_power_limit,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_limit) + { + UNITY_SET_DETAILS(CMockString_mock_get_power_limit,CMockString_power_limit); + if (cmock_call_instance->Expected_power_limit == NULL) + { UNITY_TEST_ASSERT_NULL(power_limit, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power_limit, power_limit, cmock_call_instance->Expected_power_limit_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.mock_get_power_limit_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.mock_get_power_limit_CallbackFunctionPointer(id, power_limit, Mock.mock_get_power_limit_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_power_limit_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(power_limit, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)power_limit, (void*)cmock_call_instance->ReturnThruPtr_power_limit_Val, + cmock_call_instance->ReturnThruPtr_power_limit_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_mock_get_power_limit(CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth); +void CMockExpectParameters_mock_get_power_limit(CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power_limit, int power_limit_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_limit = power_limit; + cmock_call_instance->Expected_power_limit_Depth = power_limit_Depth; + cmock_call_instance->IgnoreArg_power_limit = 0; + cmock_call_instance->ReturnThruPtr_power_limit_Used = 0; +} + +void mock_get_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_get_power_limit_CALL_INSTANCE)); + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_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.mock_get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_get_power_limit_CallInstance, cmock_guts_index); + Mock.mock_get_power_limit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.mock_get_power_limit_IgnoreBool = (char)1; +} + +void mock_get_power_limit_CMockStopIgnore(void) +{ + if(Mock.mock_get_power_limit_IgnoreBool) + Mock.mock_get_power_limit_CallInstance = CMock_Guts_MemNext(Mock.mock_get_power_limit_CallInstance); + Mock.mock_get_power_limit_IgnoreBool = (char)0; +} + +void mock_get_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_get_power_limit_CALL_INSTANCE)); + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_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.mock_get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_get_power_limit_CallInstance, cmock_guts_index); + Mock.mock_get_power_limit_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 mock_get_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_get_power_limit_CALL_INSTANCE)); + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_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.mock_get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_get_power_limit_CallInstance, cmock_guts_index); + Mock.mock_get_power_limit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mock_get_power_limit(cmock_call_instance, id, power_limit, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mock_get_power_limit_AddCallback(CMOCK_mock_get_power_limit_CALLBACK Callback) +{ + Mock.mock_get_power_limit_IgnoreBool = (char)0; + Mock.mock_get_power_limit_CallbackBool = (char)1; + Mock.mock_get_power_limit_CallbackFunctionPointer = Callback; +} + +void mock_get_power_limit_Stub(CMOCK_mock_get_power_limit_CALLBACK Callback) +{ + Mock.mock_get_power_limit_IgnoreBool = (char)0; + Mock.mock_get_power_limit_CallbackBool = (char)0; + Mock.mock_get_power_limit_CallbackFunctionPointer = Callback; +} + +void mock_get_power_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_get_power_limit_CALL_INSTANCE)); + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_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.mock_get_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_get_power_limit_CallInstance, cmock_guts_index); + Mock.mock_get_power_limit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mock_get_power_limit(cmock_call_instance, id, power_limit, power_limit_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mock_get_power_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size) +{ + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_get_power_limit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_power_limit_Used = 1; + cmock_call_instance->ReturnThruPtr_power_limit_Val = power_limit; + cmock_call_instance->ReturnThruPtr_power_limit_Size = cmock_size; +} + +void mock_get_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_get_power_limit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void mock_get_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mock_get_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_get_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_get_power_limit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_power_limit = 1; +} + +int mock_set_power_limit(fwk_id_t id, uint32_t power_limit) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_mock_set_power_limit); + cmock_call_instance = (CMOCK_mock_set_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.mock_set_power_limit_CallInstance); + Mock.mock_set_power_limit_CallInstance = CMock_Guts_MemNext(Mock.mock_set_power_limit_CallInstance); + if (Mock.mock_set_power_limit_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.mock_set_power_limit_FinalReturn; + Mock.mock_set_power_limit_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.mock_set_power_limit_CallbackBool && + Mock.mock_set_power_limit_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.mock_set_power_limit_CallbackFunctionPointer(id, power_limit, Mock.mock_set_power_limit_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_mock_set_power_limit,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_limit) + { + UNITY_SET_DETAILS(CMockString_mock_set_power_limit,CMockString_power_limit); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_power_limit, power_limit, cmock_line, CMockStringMismatch); + } + } + if (Mock.mock_set_power_limit_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.mock_set_power_limit_CallbackFunctionPointer(id, power_limit, Mock.mock_set_power_limit_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_mock_set_power_limit(CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit); +void CMockExpectParameters_mock_set_power_limit(CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_limit) +{ + 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_limit = power_limit; + cmock_call_instance->IgnoreArg_power_limit = 0; +} + +void mock_set_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_set_power_limit_CALL_INSTANCE)); + CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_limit_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.mock_set_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_set_power_limit_CallInstance, cmock_guts_index); + Mock.mock_set_power_limit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.mock_set_power_limit_IgnoreBool = (char)1; +} + +void mock_set_power_limit_CMockStopIgnore(void) +{ + if(Mock.mock_set_power_limit_IgnoreBool) + Mock.mock_set_power_limit_CallInstance = CMock_Guts_MemNext(Mock.mock_set_power_limit_CallInstance); + Mock.mock_set_power_limit_IgnoreBool = (char)0; +} + +void mock_set_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_set_power_limit_CALL_INSTANCE)); + CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_limit_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.mock_set_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_set_power_limit_CallInstance, cmock_guts_index); + Mock.mock_set_power_limit_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 mock_set_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_set_power_limit_CALL_INSTANCE)); + CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_limit_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.mock_set_power_limit_CallInstance = CMock_Guts_MemChain(Mock.mock_set_power_limit_CallInstance, cmock_guts_index); + Mock.mock_set_power_limit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mock_set_power_limit(cmock_call_instance, id, power_limit); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mock_set_power_limit_AddCallback(CMOCK_mock_set_power_limit_CALLBACK Callback) +{ + Mock.mock_set_power_limit_IgnoreBool = (char)0; + Mock.mock_set_power_limit_CallbackBool = (char)1; + Mock.mock_set_power_limit_CallbackFunctionPointer = Callback; +} + +void mock_set_power_limit_Stub(CMOCK_mock_set_power_limit_CALLBACK Callback) +{ + Mock.mock_set_power_limit_IgnoreBool = (char)0; + Mock.mock_set_power_limit_CallbackBool = (char)0; + Mock.mock_set_power_limit_CallbackFunctionPointer = Callback; +} + +void mock_set_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_set_power_limit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void mock_set_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mock_set_power_limit_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_limit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_set_power_limit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_power_limit = 1; +} + +int mock_set_power_demand(fwk_id_t id, uint32_t power_demand) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_mock_set_power_demand); + cmock_call_instance = (CMOCK_mock_set_power_demand_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.mock_set_power_demand_CallInstance); + Mock.mock_set_power_demand_CallInstance = CMock_Guts_MemNext(Mock.mock_set_power_demand_CallInstance); + if (Mock.mock_set_power_demand_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.mock_set_power_demand_FinalReturn; + Mock.mock_set_power_demand_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.mock_set_power_demand_CallbackBool && + Mock.mock_set_power_demand_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.mock_set_power_demand_CallbackFunctionPointer(id, power_demand, Mock.mock_set_power_demand_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_mock_set_power_demand,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_demand) + { + UNITY_SET_DETAILS(CMockString_mock_set_power_demand,CMockString_power_demand); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_power_demand, power_demand, cmock_line, CMockStringMismatch); + } + } + if (Mock.mock_set_power_demand_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.mock_set_power_demand_CallbackFunctionPointer(id, power_demand, Mock.mock_set_power_demand_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_mock_set_power_demand(CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_demand); +void CMockExpectParameters_mock_set_power_demand(CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t power_demand) +{ + 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_demand = power_demand; + cmock_call_instance->IgnoreArg_power_demand = 0; +} + +void mock_set_power_demand_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_set_power_demand_CALL_INSTANCE)); + CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_demand_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.mock_set_power_demand_CallInstance = CMock_Guts_MemChain(Mock.mock_set_power_demand_CallInstance, cmock_guts_index); + Mock.mock_set_power_demand_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.mock_set_power_demand_IgnoreBool = (char)1; +} + +void mock_set_power_demand_CMockStopIgnore(void) +{ + if(Mock.mock_set_power_demand_IgnoreBool) + Mock.mock_set_power_demand_CallInstance = CMock_Guts_MemNext(Mock.mock_set_power_demand_CallInstance); + Mock.mock_set_power_demand_IgnoreBool = (char)0; +} + +void mock_set_power_demand_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_set_power_demand_CALL_INSTANCE)); + CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_demand_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.mock_set_power_demand_CallInstance = CMock_Guts_MemChain(Mock.mock_set_power_demand_CallInstance, cmock_guts_index); + Mock.mock_set_power_demand_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 mock_set_power_demand_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_demand, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mock_set_power_demand_CALL_INSTANCE)); + CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_demand_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.mock_set_power_demand_CallInstance = CMock_Guts_MemChain(Mock.mock_set_power_demand_CallInstance, cmock_guts_index); + Mock.mock_set_power_demand_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mock_set_power_demand(cmock_call_instance, id, power_demand); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mock_set_power_demand_AddCallback(CMOCK_mock_set_power_demand_CALLBACK Callback) +{ + Mock.mock_set_power_demand_IgnoreBool = (char)0; + Mock.mock_set_power_demand_CallbackBool = (char)1; + Mock.mock_set_power_demand_CallbackFunctionPointer = Callback; +} + +void mock_set_power_demand_Stub(CMOCK_mock_set_power_demand_CALLBACK Callback) +{ + Mock.mock_set_power_demand_IgnoreBool = (char)0; + Mock.mock_set_power_demand_CallbackBool = (char)0; + Mock.mock_set_power_demand_CallbackFunctionPointer = Callback; +} + +void mock_set_power_demand_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_demand_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_set_power_demand_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void mock_set_power_demand_CMockIgnoreArg_power_demand(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mock_set_power_demand_CALL_INSTANCE* cmock_call_instance = (CMOCK_mock_set_power_demand_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mock_set_power_demand_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_power_demand = 1; +} + diff --git a/module/power_distributor/test/mocks/Mockmod_power_distributor_extra.h b/module/power_distributor/test/mocks/Mockmod_power_distributor_extra.h new file mode 100644 index 000000000..9e672c134 --- /dev/null +++ b/module/power_distributor/test/mocks/Mockmod_power_distributor_extra.h @@ -0,0 +1,88 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _MOCKMOD_POWER_DISTRIBUTOR_EXTRA_H +#define _MOCKMOD_POWER_DISTRIBUTOR_EXTRA_H + +#include "unity.h" +#include "mod_power_distributor_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_distributor_extra_Init(void); +void Mockmod_power_distributor_extra_Destroy(void); +void Mockmod_power_distributor_extra_Verify(void); + + + + +#define mock_get_power_limit_IgnoreAndReturn(cmock_retval) mock_get_power_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void mock_get_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mock_get_power_limit_StopIgnore() mock_get_power_limit_CMockStopIgnore() +void mock_get_power_limit_CMockStopIgnore(void); +#define mock_get_power_limit_ExpectAnyArgsAndReturn(cmock_retval) mock_get_power_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void mock_get_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mock_get_power_limit_ExpectAndReturn(id, power_limit, cmock_retval) mock_get_power_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) +void mock_get_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int cmock_to_return); +typedef int (* CMOCK_mock_get_power_limit_CALLBACK)(fwk_id_t id, uint32_t* power_limit, int cmock_num_calls); +void mock_get_power_limit_AddCallback(CMOCK_mock_get_power_limit_CALLBACK Callback); +void mock_get_power_limit_Stub(CMOCK_mock_get_power_limit_CALLBACK Callback); +#define mock_get_power_limit_StubWithCallback mock_get_power_limit_Stub +#define mock_get_power_limit_ExpectWithArrayAndReturn(id, power_limit, power_limit_Depth, cmock_retval) mock_get_power_limit_CMockExpectWithArrayAndReturn(__LINE__, id, power_limit, power_limit_Depth, cmock_retval) +void mock_get_power_limit_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power_limit, int power_limit_Depth, int cmock_to_return); +#define mock_get_power_limit_ReturnThruPtr_power_limit(power_limit) mock_get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, sizeof(uint32_t)) +#define mock_get_power_limit_ReturnArrayThruPtr_power_limit(power_limit, cmock_len) mock_get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_len * sizeof(*power_limit)) +#define mock_get_power_limit_ReturnMemThruPtr_power_limit(power_limit, cmock_size) mock_get_power_limit_CMockReturnMemThruPtr_power_limit(__LINE__, power_limit, cmock_size) +void mock_get_power_limit_CMockReturnMemThruPtr_power_limit(UNITY_LINE_TYPE cmock_line, uint32_t* power_limit, size_t cmock_size); +#define mock_get_power_limit_IgnoreArg_id() mock_get_power_limit_CMockIgnoreArg_id(__LINE__) +void mock_get_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define mock_get_power_limit_IgnoreArg_power_limit() mock_get_power_limit_CMockIgnoreArg_power_limit(__LINE__) +void mock_get_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line); +#define mock_set_power_limit_IgnoreAndReturn(cmock_retval) mock_set_power_limit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void mock_set_power_limit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mock_set_power_limit_StopIgnore() mock_set_power_limit_CMockStopIgnore() +void mock_set_power_limit_CMockStopIgnore(void); +#define mock_set_power_limit_ExpectAnyArgsAndReturn(cmock_retval) mock_set_power_limit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void mock_set_power_limit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mock_set_power_limit_ExpectAndReturn(id, power_limit, cmock_retval) mock_set_power_limit_CMockExpectAndReturn(__LINE__, id, power_limit, cmock_retval) +void mock_set_power_limit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_limit, int cmock_to_return); +typedef int (* CMOCK_mock_set_power_limit_CALLBACK)(fwk_id_t id, uint32_t power_limit, int cmock_num_calls); +void mock_set_power_limit_AddCallback(CMOCK_mock_set_power_limit_CALLBACK Callback); +void mock_set_power_limit_Stub(CMOCK_mock_set_power_limit_CALLBACK Callback); +#define mock_set_power_limit_StubWithCallback mock_set_power_limit_Stub +#define mock_set_power_limit_IgnoreArg_id() mock_set_power_limit_CMockIgnoreArg_id(__LINE__) +void mock_set_power_limit_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define mock_set_power_limit_IgnoreArg_power_limit() mock_set_power_limit_CMockIgnoreArg_power_limit(__LINE__) +void mock_set_power_limit_CMockIgnoreArg_power_limit(UNITY_LINE_TYPE cmock_line); +#define mock_set_power_demand_IgnoreAndReturn(cmock_retval) mock_set_power_demand_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void mock_set_power_demand_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mock_set_power_demand_StopIgnore() mock_set_power_demand_CMockStopIgnore() +void mock_set_power_demand_CMockStopIgnore(void); +#define mock_set_power_demand_ExpectAnyArgsAndReturn(cmock_retval) mock_set_power_demand_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void mock_set_power_demand_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mock_set_power_demand_ExpectAndReturn(id, power_demand, cmock_retval) mock_set_power_demand_CMockExpectAndReturn(__LINE__, id, power_demand, cmock_retval) +void mock_set_power_demand_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t power_demand, int cmock_to_return); +typedef int (* CMOCK_mock_set_power_demand_CALLBACK)(fwk_id_t id, uint32_t power_demand, int cmock_num_calls); +void mock_set_power_demand_AddCallback(CMOCK_mock_set_power_demand_CALLBACK Callback); +void mock_set_power_demand_Stub(CMOCK_mock_set_power_demand_CALLBACK Callback); +#define mock_set_power_demand_StubWithCallback mock_set_power_demand_Stub +#define mock_set_power_demand_IgnoreArg_id() mock_set_power_demand_CMockIgnoreArg_id(__LINE__) +void mock_set_power_demand_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define mock_set_power_demand_IgnoreArg_power_demand() mock_set_power_demand_CMockIgnoreArg_power_demand(__LINE__) +void mock_set_power_demand_CMockIgnoreArg_power_demand(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/power_distributor/test/mod_power_distributor_extra.h b/module/power_distributor/test/mod_power_distributor_extra.h new file mode 100644 index 000000000..b15187d3d --- /dev/null +++ b/module/power_distributor/test/mod_power_distributor_extra.h @@ -0,0 +1,20 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Description: + * Power unit test support. + */ + +#ifndef MOD_POWER_DISTRIBUTOR_EXTRA_H +#define MOD_POWER_DISTRIBUTOR_EXTRA_H + +#include + +int mock_get_power_limit(fwk_id_t id, uint32_t *power_limit); +int mock_set_power_limit(fwk_id_t id, uint32_t power_limit); +int mock_set_power_demand(fwk_id_t id, uint32_t power_demand); + +#endif /* MOD_POWER_DISTRIBUTOR_EXTRA_H */ diff --git a/module/power_distributor/test/mod_power_distributor_unit_test.c b/module/power_distributor/test/mod_power_distributor_unit_test.c index 3d425ffeb..8f348d086 100644 --- a/module/power_distributor/test/mod_power_distributor_unit_test.c +++ b/module/power_distributor/test/mod_power_distributor_unit_test.c @@ -14,14 +14,22 @@ #include #include +#include #include +#include + +#include #include UNIT_TEST_SRC struct mod_power_distributor_domain_ctx test_ctx_table[TEST_DOMAIN_COUNT]; -struct interface_power_management_api test_power_management_api = { 0 }; +struct interface_power_management_api test_power_management_api = { + .get_power_limit = &mock_get_power_limit, + .set_power_limit = &mock_set_power_limit, + .set_power_demand = &mock_set_power_demand, +}; void setUp(void) { @@ -30,11 +38,16 @@ void setUp(void) power_distributor_ctx.domain_count = TEST_DOMAIN_COUNT; for (unsigned int i = 0U; i < TEST_DOMAIN_COUNT; i++) { - power_distributor_ctx.domain[i].controller_api = - &test_power_management_api; + if (fwk_optional_id_is_defined( + test_power_distibutor_domain_config[i].controller_id)) { + power_distributor_ctx.domain[i].controller_api = + &test_power_management_api; + } power_distributor_ctx.domain[i].config = &test_power_distibutor_domain_config[i]; } + Mockfwk_mm_Init(); + Mockmod_power_distributor_extra_Init(); } void utest_power_distributor_init_success(void) @@ -97,7 +110,8 @@ void utest_mod_distributor_bind_round_0(void) struct mod_power_distributor_domain_ctx *domain_ctx = &(power_distributor_ctx.domain[index]); - if (!fwk_id_is_equal( + if (fwk_optional_id_is_defined(domain_ctx->config->controller_api_id) && + !fwk_id_is_equal( domain_ctx->config->controller_api_id, FWK_ID_NONE)) { fwk_module_bind_ExpectAndReturn( fwk_id_build_module_id(domain_ctx->config->controller_api_id), @@ -280,8 +294,36 @@ void utest_mod_distributor_set_power_limit_demand_api_invalid_params(void) TEST_ASSERT_EQUAL(FWK_E_PARAM, status); } +void utest_mod_distributor_system_power_distribute(void) +{ + int status = FWK_E_INIT; + for (size_t i = 0; i < power_distributor_ctx.domain_count; ++i) { + struct mod_power_distributor_domain_ctx *domain_ctx = + &power_distributor_ctx.domain[i]; + domain_ctx->node.data.power_limit = 0xDEADBEEF + i; + } + + for (size_t i = 0; i < power_distributor_ctx.domain_count; ++i) { + struct mod_power_distributor_domain_ctx *domain_ctx = + &power_distributor_ctx.domain[i]; + + if (domain_ctx->controller_api != NULL) { + fwk_id_t elem_id = + FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_CONTROLLER, i); + fwk_module_get_element_name_ExpectAnyArgsAndReturn(""); + mock_set_power_limit_ExpectAndReturn( + elem_id, domain_ctx->node.data.power_limit, FWK_SUCCESS); + } + } + + status = system_power_distribute(); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + void tearDown(void) { + Mockmod_power_distributor_extra_Verify(); + Mockfwk_mm_Verify(); } int power_distributor_test_main(void) @@ -298,6 +340,7 @@ int power_distributor_test_main(void) RUN_TEST(utest_mod_distributor_post_init_success); RUN_TEST(utest_mod_distributor_set_power_limit_demand_api_success); RUN_TEST(utest_mod_distributor_set_power_limit_demand_api_invalid_params); + RUN_TEST(utest_mod_distributor_system_power_distribute); return UNITY_END(); } -- GitLab