1 /*
2  * Arm SCP/MCP Software
3  * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
4  *
5  * SPDX-License-Identifier: BSD-3-Clause
6  */
7 
8 #include "scp_unity.h"
9 #include "unity.h"
10 
11 #include <Mockfwk_id.h>
12 #include <Mockfwk_mm.h>
13 #include <Mockfwk_module.h>
14 #include <Mockmod_power_allocator_extra.h>
15 #include <Mockscmi_power_capping_protocol.h>
16 
17 #include <stdarg.h>
18 
19 #include UNIT_TEST_SRC
20 
21 #include "mod_scmi_power_capping_unit_test.h"
22 
23 static int status;
24 
25 static const struct mod_scmi_power_capping_domain_config
26     scmi_power_capping_default_config = {
27         .parent_idx = __LINE__,
28     };
29 
30 /* Test functions */
31 /* Initialize the tests */
32 
setUp(void)33 void setUp(void)
34 {
35 }
36 
tearDown(void)37 void tearDown(void)
38 {
39 }
40 
utest_scmi_power_capping_init_invalid_element_count(void)41 void utest_scmi_power_capping_init_invalid_element_count(void)
42 {
43     status = scmi_power_capping_init(fwk_module_id_scmi_power_capping, 0, NULL);
44     TEST_ASSERT_EQUAL(status, FWK_E_SUPPORT);
45 }
46 
utest_scmi_power_capping_init_success(void)47 void utest_scmi_power_capping_init_success(void)
48 {
49     uint32_t domain_count = __LINE__;
50     struct mod_scmi_power_capping_domain_context *domain_table =
51         (struct mod_scmi_power_capping_domain_context *)__LINE__;
52 
53     struct mod_scmi_power_capping_context expected_ctx = { 0 };
54 
55     expected_ctx.power_capping_domain_ctx_table = domain_table,
56     expected_ctx.domain_count = domain_count,
57 
58     fwk_mm_calloc_ExpectAndReturn(
59         domain_count,
60         sizeof(struct mod_scmi_power_capping_domain_context),
61         domain_table);
62 
63 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
64     pcapping_protocol_init_ExpectWithArray(&expected_ctx, 1);
65 #endif
66 
67     status = scmi_power_capping_init(
68         fwk_module_id_scmi_power_capping, domain_count, NULL);
69     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
70 }
71 
utest_scmi_power_capping_element_init_success(void)72 void utest_scmi_power_capping_element_init_success(void)
73 {
74     uint32_t domain_idx = __LINE__;
75     uint32_t domain_count = __LINE__;
76     fwk_id_t domain_id =
77         FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_SCMI_POWER_CAPPING, domain_idx);
78 
79     fwk_id_get_element_idx_ExpectAndReturn(domain_id, domain_idx);
80 
81 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
82     pcapping_protocol_domain_init_ExpectAndReturn(
83         domain_idx, &scmi_power_capping_default_config, FWK_SUCCESS);
84 #endif
85 
86     status = scmi_power_capping_element_init(
87         domain_id, domain_count, &scmi_power_capping_default_config);
88     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
89 }
90 
utest_scmi_power_capping_element_init_null_config(void)91 void utest_scmi_power_capping_element_init_null_config(void)
92 {
93     fwk_id_t domain_id =
94         FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_SCMI_POWER_CAPPING, __LINE__);
95     uint32_t domain_count = __LINE__;
96     status = scmi_power_capping_element_init(domain_id, domain_count, NULL);
97     TEST_ASSERT_EQUAL(status, FWK_E_PARAM);
98 }
99 
utest_scmi_power_capping_element_init_failure(void)100 void utest_scmi_power_capping_element_init_failure(void)
101 {
102     uint32_t domain_count = __LINE__;
103     fwk_id_t domain_id =
104         FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_SCMI_POWER_CAPPING, domain_count);
105 
106     fwk_id_get_element_idx_ExpectAndReturn(domain_id, domain_count);
107 
108 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
109     pcapping_protocol_domain_init_ExpectAndReturn(
110         domain_count, &scmi_power_capping_default_config, FWK_E_PARAM);
111 #endif
112 
113     status = scmi_power_capping_element_init(
114         domain_id, domain_count, &scmi_power_capping_default_config);
115     TEST_ASSERT_EQUAL(status, FWK_E_PARAM);
116 }
117 
utest_scmi_power_capping_bind_success(void)118 void utest_scmi_power_capping_bind_success(void)
119 {
120     fwk_id_t bind_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_SCMI_POWER_CAPPING);
121     fwk_id_is_type_ExpectAndReturn(bind_id, FWK_ID_TYPE_ELEMENT, false);
122     fwk_module_bind_ExpectAndReturn(
123         FWK_ID_MODULE(FWK_MODULE_IDX_POWER_ALLOCATOR),
124         FWK_ID_API(
125             FWK_MODULE_IDX_POWER_ALLOCATOR, MOD_POWER_ALLOCATOR_API_IDX_CAP),
126         &(power_management_apis.power_allocator_api),
127         FWK_SUCCESS);
128 
129     fwk_module_bind_ExpectAndReturn(
130         FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR),
131         FWK_ID_API(
132             FWK_MODULE_IDX_POWER_COORDINATOR,
133             MOD_POWER_COORDINATOR_API_IDX_PERIOD),
134         &(power_management_apis.power_coordinator_api),
135         FWK_SUCCESS);
136 
137     fwk_module_bind_ExpectAndReturn(
138         FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER),
139         FWK_ID_API(
140             FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT),
141         &(power_management_apis.power_meter_api),
142         FWK_SUCCESS);
143 
144 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
145     pcapping_protocol_bind_ExpectAndReturn(FWK_SUCCESS);
146     pcapping_protocol_set_power_apis_Expect(&power_management_apis);
147 #endif
148 
149     status = scmi_power_capping_bind(bind_id, 0);
150     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
151 }
152 
utest_scmi_power_capping_bind_success_round_1(void)153 void utest_scmi_power_capping_bind_success_round_1(void)
154 {
155     fwk_id_t bind_id;
156     status = scmi_power_capping_bind(bind_id, 1);
157     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
158 }
159 
utest_scmi_power_capping_bind_failure(void)160 void utest_scmi_power_capping_bind_failure(void)
161 {
162     fwk_id_t bind_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_SCMI_POWER_CAPPING);
163     fwk_id_is_type_ExpectAndReturn(bind_id, FWK_ID_TYPE_ELEMENT, false);
164     fwk_module_bind_ExpectAndReturn(
165         FWK_ID_MODULE(FWK_MODULE_IDX_POWER_ALLOCATOR),
166         FWK_ID_API(
167             FWK_MODULE_IDX_POWER_ALLOCATOR, MOD_POWER_ALLOCATOR_API_IDX_CAP),
168         &(power_management_apis.power_allocator_api),
169         FWK_SUCCESS);
170 
171     fwk_module_bind_ExpectAndReturn(
172         FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR),
173         FWK_ID_API(
174             FWK_MODULE_IDX_POWER_COORDINATOR,
175             MOD_POWER_COORDINATOR_API_IDX_PERIOD),
176         &(power_management_apis.power_coordinator_api),
177         FWK_SUCCESS);
178 
179     fwk_module_bind_ExpectAndReturn(
180         FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER),
181         FWK_ID_API(
182             FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT),
183         &(power_management_apis.power_meter_api),
184         FWK_SUCCESS);
185 
186 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
187     pcapping_protocol_bind_ExpectAndReturn(FWK_E_INIT);
188 #endif
189 
190     status = scmi_power_capping_bind(bind_id, 0);
191     TEST_ASSERT_EQUAL(status, FWK_E_INIT);
192 }
193 
utest_scmi_power_capping_start(void)194 void utest_scmi_power_capping_start(void)
195 {
196     fwk_id_t id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_CAPPING, 10u);
197     int status = FWK_SUCCESS;
198 
199 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
200     pcapping_protocol_start_ExpectAndReturn(id, FWK_SUCCESS);
201 #endif
202 
203     status = scmi_power_capping_start(id);
204 
205     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
206 }
207 
utest_scmi_power_capping_process_notification(void)208 void utest_scmi_power_capping_process_notification(void)
209 {
210     int status;
211 
212     struct fwk_event notification_event = { 0 };
213 
214 #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS
215     pcapping_protocol_process_notification_ExpectAndReturn(
216         &notification_event, FWK_SUCCESS);
217 #endif
218 
219     status = scmi_power_capping_process_notification(&notification_event, NULL);
220 
221     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
222 }
223 
utest_scmi_power_capping_process_bind_request(void)224 void utest_scmi_power_capping_process_bind_request(void)
225 {
226     fwk_id_t source_id = FWK_ID_MODULE(FWK_MODULE_IDX_SCMI);
227     fwk_id_t target_id;
228     const void *api;
229     fwk_id_t api_id = FWK_ID_API(
230         FWK_MODULE_IDX_SCMI_POWER_CAPPING,
231         MOD_SCMI_POWER_CAPPING_API_IDX_REQUEST);
232 
233     fwk_id_is_equal_ExpectAndReturn(source_id, source_id, true);
234     pcapping_protocol_process_bind_request_ExpectAndReturn(
235         api_id, &api, FWK_SUCCESS);
236 
237     status = scmi_power_capping_process_bind_request(
238         source_id, target_id, api_id, &api);
239     TEST_ASSERT_EQUAL(status, FWK_SUCCESS);
240 }
241 
utest_scmi_power_capping_process_bind_request_failure(void)242 void utest_scmi_power_capping_process_bind_request_failure(void)
243 {
244     fwk_id_t source_id;
245     fwk_id_t target_id;
246     const void *api;
247     fwk_id_t api_id = FWK_ID_API(
248         FWK_MODULE_IDX_SCMI_POWER_CAPPING,
249         MOD_SCMI_POWER_CAPPING_API_IDX_REQUEST);
250 
251     fwk_id_is_equal_ExpectAndReturn(
252         source_id, FWK_ID_MODULE(FWK_MODULE_IDX_SCMI), false);
253 
254     status = scmi_power_capping_process_bind_request(
255         source_id, target_id, api_id, &api);
256     TEST_ASSERT_EQUAL(status, FWK_E_ACCESS);
257 }
258 
scmi_test_main(void)259 int scmi_test_main(void)
260 {
261     UNITY_BEGIN();
262     RUN_TEST(utest_scmi_power_capping_init_invalid_element_count);
263     RUN_TEST(utest_scmi_power_capping_init_success);
264     RUN_TEST(utest_scmi_power_capping_element_init_success);
265     RUN_TEST(utest_scmi_power_capping_element_init_null_config);
266     RUN_TEST(utest_scmi_power_capping_element_init_failure);
267     RUN_TEST(utest_scmi_power_capping_bind_success);
268     RUN_TEST(utest_scmi_power_capping_bind_success_round_1);
269     RUN_TEST(utest_scmi_power_capping_bind_failure);
270     RUN_TEST(utest_scmi_power_capping_start);
271     RUN_TEST(utest_scmi_power_capping_process_notification);
272     RUN_TEST(utest_scmi_power_capping_process_bind_request);
273     RUN_TEST(utest_scmi_power_capping_process_bind_request_failure);
274     return UNITY_END();
275 }
276 
277 #if !defined(TEST_ON_TARGET)
main(void)278 int main(void)
279 {
280     return scmi_test_main();
281 }
282 #endif
283