1 /*
2  * Arm SCP/MCP Software
3  * Copyright (c) 2022-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 <internal/scmi_perf.h>
12 
13 #ifdef TEST_ON_TARGET
14 #    include <fwk_id.h>
15 #    include <fwk_module.h>
16 #else
17 #    include <Mockfwk_id.h>
18 #    include <Mockfwk_mm.h>
19 #    include <Mockfwk_module.h>
20 
21 #    include <internal/Mockfwk_core_internal.h>
22 #endif
23 #include <Mockmod_scmi_perf_fch_extra.h>
24 #include <config_scmi_perf.h>
25 #include <scmi_perf_fastchannels.c>
26 #include <scmi_perf_protocol_ops.c>
27 
28 #include <mod_dvfs.h>
29 #include <mod_scmi_perf.h>
30 
31 #include <fwk_element.h>
32 #include <fwk_macros.h>
33 #include UNIT_TEST_SRC
34 
35 static struct mod_scmi_perf_ctx scmi_perf_ctx;
36 
37 struct mod_scmi_to_protocol_api *to_protocol_api = NULL;
38 
39 struct mod_scmi_from_protocol_api from_protocol_api = {
40     .get_agent_count = mod_scmi_from_protocol_api_get_agent_count,
41     .get_agent_id = mod_scmi_from_protocol_api_get_agent_id,
42     .get_agent_type = mod_scmi_from_protocol_api_get_agent_type,
43     .get_max_payload_size = mod_scmi_from_protocol_api_get_max_payload_size,
44     .write_payload = mod_scmi_from_protocol_api_write_payload,
45     .respond = mod_scmi_from_protocol_api_respond,
46     .scmi_message_validation = mod_scmi_from_protocol_api_scmi_frame_validation,
47     .notify = mod_scmi_from_protocol_api_notify,
48 };
49 
50 static const struct mod_dvfs_domain_api dvfs_domain_api = {
51     .get_current_opp = mod_dvfs_domain_api_get_current_opp,
52     .get_sustained_opp = mod_dvfs_domain_api_get_sustained_opp,
53     .get_nth_opp = mod_dvfs_domain_api_get_nth_opp,
54     .get_level_id = mod_dvfs_domain_api_get_level_id,
55     .get_opp_count = mod_dvfs_domain_api_get_opp_count,
56     .get_latency = mod_dvfs_domain_api_get_latency,
57     .set_level = mod_dvfs_domain_api_set_level,
58 };
59 
60 char *name = "Test Name";
61 
62 static int return_status;
63 
setUp(void)64 void setUp(void)
65 {
66     scmi_perf_ctx.scmi_api = &from_protocol_api;
67     scmi_perf_ctx.config = config_scmi_perf.data;
68     scmi_perf_ctx.domain_count = scmi_perf_ctx.config->perf_doms_count;
69 
70     perf_fch_ctx.perf_ctx = &scmi_perf_ctx;
71     perf_fch_ctx.fast_channels_rate_limit = SCMI_PERF_FC_MIN_RATE_LIMIT;
72 
73     to_protocol_api = &scmi_perf_mod_scmi_to_protocol_api;
74     perf_prot_ctx.scmi_perf_ctx = &scmi_perf_ctx;
75 
76     scmi_perf_ctx.dvfs_api = &dvfs_domain_api;
77 }
78 
tearDown(void)79 void tearDown(void)
80 {
81 }
82 
83 /*
84  * Test that the scmi_perf_protocol_version_handler function returns the correct
85  * version of the protocol
86  */
87 
version_handler_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)88 int version_handler_respond_callback(
89     fwk_id_t service_id,
90     const void *payload,
91     size_t size,
92     int NumCalls)
93 {
94     struct scmi_protocol_version_p2a *return_values;
95     return_values = (struct scmi_protocol_version_p2a *)payload;
96 
97     TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status);
98     TEST_ASSERT_EQUAL(SCMI_PROTOCOL_VERSION_PERF, return_values->version);
99 
100     return FWK_SUCCESS;
101 }
102 
version_handler_respond_callback_fail(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)103 int version_handler_respond_callback_fail(
104     fwk_id_t service_id,
105     const void *payload,
106     size_t size,
107     int NumCalls)
108 {
109     struct scmi_protocol_version_p2a *return_values;
110     return_values = (struct scmi_protocol_version_p2a *)payload;
111 
112     TEST_ASSERT_EQUAL(size, sizeof(int32_t));
113     TEST_ASSERT_EQUAL(return_status, return_values->status);
114 
115     return FWK_SUCCESS;
116 }
117 
118 /*
119  * Test that the scmi_perf_protocol_attributes_handler function returns the
120  * correct attributes associated with this protocol.
121  */
attributes_handler_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)122 int attributes_handler_respond_callback(
123     fwk_id_t service_id,
124     const void *payload,
125     size_t size,
126     int NumCalls)
127 {
128     struct scmi_perf_protocol_attributes_p2a *return_values;
129     return_values = (struct scmi_perf_protocol_attributes_p2a *)payload;
130 
131     TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status);
132     TEST_ASSERT_EQUAL(
133         SCMI_PERF_PROTOCOL_ATTRIBUTES(true, scmi_perf_ctx.domain_count),
134         return_values->attributes);
135     TEST_ASSERT_EQUAL(0, return_values->statistics_len);
136 
137     return FWK_SUCCESS;
138 }
139 
140 /* Test the message_attributes_handler function with a valid message_id */
message_attributes_handler_valid_param_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)141 int message_attributes_handler_valid_param_respond_callback(
142     fwk_id_t service_id,
143     const void *payload,
144     size_t size,
145     int NumCalls)
146 {
147     struct scmi_protocol_message_attributes_p2a *return_values;
148     return_values = (struct scmi_protocol_message_attributes_p2a *)payload;
149 
150     TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status);
151 
152     TEST_ASSERT_EQUAL(1, return_values->attributes);
153 
154     return FWK_SUCCESS;
155 }
156 
utest_scmi_perf_protocol_message_attributes_handler_valid_param(void)157 void utest_scmi_perf_protocol_message_attributes_handler_valid_param(void)
158 {
159     int status;
160     fwk_id_t service_id =
161         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
162 
163     struct scmi_protocol_message_attributes_a2p payload = {
164         .message_id = MOD_SCMI_PERF_LIMITS_GET,
165     };
166 
167     mod_scmi_from_protocol_api_respond_Stub(
168         message_attributes_handler_valid_param_respond_callback);
169     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
170         SCMI_SUCCESS);
171     status = to_protocol_api->message_handler(
172         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
173         service_id,
174         (const uint32_t *)&payload,
175         payload_size_table[MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES],
176         MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES);
177 
178     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
179 }
180 
181 /* Test the message_attributes_handler function with an invalid message_id */
message_attributes_handler_invalid_param_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)182 int message_attributes_handler_invalid_param_respond_callback(
183     fwk_id_t service_id,
184     const void *payload,
185     size_t size,
186     int NumCalls)
187 {
188     struct scmi_protocol_message_attributes_p2a *return_values;
189     return_values = (struct scmi_protocol_message_attributes_p2a *)payload;
190 
191     TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_FOUND, return_values->status);
192 
193     return FWK_SUCCESS;
194 }
195 
utest_scmi_perf_protocol_message_attributes_handler_invalid_param(void)196 void utest_scmi_perf_protocol_message_attributes_handler_invalid_param(void)
197 {
198     int status;
199     fwk_id_t service_id =
200         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
201 
202     struct scmi_protocol_message_attributes_a2p payload = {
203         .message_id = FWK_ARRAY_SIZE(handler_table),
204     };
205 
206     mod_scmi_from_protocol_api_respond_Stub(
207         message_attributes_handler_invalid_param_respond_callback);
208     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
209         SCMI_SUCCESS);
210     status = to_protocol_api->message_handler(
211         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
212         service_id,
213         (const uint32_t *)&payload,
214         payload_size_table[MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES],
215         MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES);
216 
217     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
218 }
219 
220 /* Test the domain_attributes_handler function with a valid domain_id */
domain_attributes_handler_valid_param_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)221 int domain_attributes_handler_valid_param_respond_callback(
222     fwk_id_t service_id,
223     const void *payload,
224     size_t size,
225     int NumCalls)
226 {
227     struct scmi_perf_domain_attributes_p2a *return_values;
228     return_values = (struct scmi_perf_domain_attributes_p2a *)payload;
229 
230     TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status);
231 
232     bool notifications = false;
233     bool fast_channels = false;
234 
235     fast_channels = true;
236 
237     uint32_t permissions = ((uint32_t)MOD_SCMI_PERF_PERMS_SET_LIMITS) |
238         ((uint32_t)MOD_SCMI_PERF_PERMS_SET_LEVEL);
239 
240     uint32_t expected_attributes = SCMI_PERF_DOMAIN_ATTRIBUTES(
241         (uint32_t)notifications,
242         (uint32_t)notifications,
243         ((permissions & (uint32_t)MOD_SCMI_PERF_PERMS_SET_LEVEL) !=
244          (uint32_t)0) ?
245             1U :
246             0U,
247         ((permissions & (uint32_t)MOD_SCMI_PERF_PERMS_SET_LIMITS) !=
248          (uint32_t)0) ?
249             1U :
250             0U,
251         (uint32_t)fast_channels);
252 
253     TEST_ASSERT_EQUAL(expected_attributes, return_values->attributes);
254 
255     TEST_ASSERT_EQUAL(0, return_values->rate_limit);
256 
257     struct mod_dvfs_opp expected_opp_values = test_dvfs_config.opps[0];
258 
259     TEST_ASSERT_EQUAL(
260         expected_opp_values.frequency, return_values->sustained_freq);
261     TEST_ASSERT_EQUAL(
262         expected_opp_values.level, return_values->sustained_perf_level);
263 
264     TEST_ASSERT_EQUAL_STRING(name, (char *)return_values->name);
265 
266     return FWK_SUCCESS;
267 }
268 
utest_scmi_perf_domain_attributes_handler_valid_param(void)269 void utest_scmi_perf_domain_attributes_handler_valid_param(void)
270 {
271     int status;
272 
273     fwk_id_t service_id =
274         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
275 
276     struct scmi_perf_domain_attributes_a2p payload = {
277         .domain_id = 0,
278     };
279 
280     unsigned int agent_id = TEST_SCMI_AGENT_IDX_0;
281 
282     mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS);
283     mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id);
284 
285     struct mod_dvfs_opp test_opp_values = test_dvfs_config.opps[0];
286 
287     mod_dvfs_domain_api_get_sustained_opp_ExpectAnyArgsAndReturn(FWK_SUCCESS);
288     mod_dvfs_domain_api_get_sustained_opp_ReturnThruPtr_opp(&test_opp_values);
289 
290     fwk_module_get_element_name_ExpectAnyArgsAndReturn(name);
291     fwk_id_build_element_id_ExpectAnyArgsAndReturn(
292         FWK_ID_ELEMENT(FWK_MODULE_IDX_SCMI_PERF, payload.domain_id));
293     fwk_id_get_element_idx_ExpectAnyArgsAndReturn(0);
294 
295     mod_scmi_from_protocol_api_respond_Stub(
296         domain_attributes_handler_valid_param_respond_callback);
297     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
298         SCMI_SUCCESS);
299     status = to_protocol_api->message_handler(
300         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
301         service_id,
302         (const uint32_t *)&payload,
303         payload_size_table[MOD_SCMI_PERF_DOMAIN_ATTRIBUTES],
304         MOD_SCMI_PERF_DOMAIN_ATTRIBUTES);
305 
306     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
307 }
308 
309 /* Test the domain_attributes_handler function with an invalid domain_id */
domain_attributes_handler_invalid_param_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)310 int domain_attributes_handler_invalid_param_respond_callback(
311     fwk_id_t service_id,
312     const void *payload,
313     size_t size,
314     int NumCalls)
315 {
316     struct scmi_perf_domain_attributes_p2a *return_values;
317     return_values = (struct scmi_perf_domain_attributes_p2a *)payload;
318 
319     TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_FOUND, return_values->status);
320 
321     return FWK_SUCCESS;
322 }
323 
utest_scmi_perf_domain_attributes_handler_invalid_param(void)324 void utest_scmi_perf_domain_attributes_handler_invalid_param(void)
325 {
326     int status;
327 
328     fwk_id_t service_id =
329         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
330 
331     struct scmi_perf_domain_attributes_a2p payload = {
332         .domain_id = scmi_perf_ctx.domain_count,
333     };
334 
335     mod_scmi_from_protocol_api_respond_Stub(
336         domain_attributes_handler_invalid_param_respond_callback);
337     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
338         SCMI_SUCCESS);
339     status = to_protocol_api->message_handler(
340         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
341         service_id,
342         (const uint32_t *)&payload,
343         payload_size_table[MOD_SCMI_PERF_DOMAIN_ATTRIBUTES],
344         MOD_SCMI_PERF_DOMAIN_ATTRIBUTES);
345 
346     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
347 }
348 
349 /*
350  * As the dvfs_get_nth_opp function is mocked, we must manually return the
351  * requested OPP.
352  */
get_nth_opp_callback(fwk_id_t domain_id,size_t n,struct mod_dvfs_opp * opp,int NumCalls)353 int get_nth_opp_callback(
354     fwk_id_t domain_id,
355     size_t n,
356     struct mod_dvfs_opp *opp,
357     int NumCalls)
358 {
359     *opp = test_dvfs_config.opps[n];
360     return FWK_SUCCESS;
361 }
362 
363 /*
364  * Test the scmi_perf_describe_fast_channels function with a set of valid
365  * parameters.
366  */
describe_fast_channels_valid_params_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)367 int describe_fast_channels_valid_params_respond_callback(
368     fwk_id_t service_id,
369     const void *payload,
370     size_t size,
371     int NumCalls)
372 {
373     struct scmi_perf_describe_fc_p2a *return_values =
374         (struct scmi_perf_describe_fc_p2a *)payload;
375 
376     TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status);
377     TEST_ASSERT_EQUAL(0, return_values->attributes);
378     int chan_index = (uint32_t)MOD_SCMI_PERF_FAST_CHANNEL_LEVEL_GET;
379 
380 #ifdef BUILD_HAS_SCMI_PERF_FAST_CHANNELS
381     TEST_ASSERT_EQUAL(
382         (uint32_t)(FAKE_FCH0_AP_ADDRESS & ~0UL), return_values->chan_addr_low);
383     TEST_ASSERT_EQUAL(
384         (uint32_t)(FAKE_FCH0_AP_ADDRESS >> 32), return_values->chan_addr_high);
385 #endif
386     TEST_ASSERT_EQUAL(
387         fast_channel_elem_size[chan_index], return_values->chan_size);
388 
389     return FWK_SUCCESS;
390 }
391 
utest_scmi_perf_describe_fast_channels_valid_params(void)392 void utest_scmi_perf_describe_fast_channels_valid_params(void)
393 {
394     int status;
395 #ifdef BUILD_HAS_SCMI_PERF_FAST_CHANNELS
396     struct scmi_perf_domain_ctx domain0_ctx;
397     struct fast_channel_ctx *fch0_ctx =
398         &domain0_ctx.fch_ctx[MOD_SCMI_PERF_FAST_CHANNEL_LEVEL_GET];
399 
400     fch0_ctx->fch_address.target_view_address = FAKE_FCH0_AP_ADDRESS;
401     fch0_ctx->fch_address.local_view_address = FAKE_FCH0_SCP_ADDRESS;
402     fch0_ctx->fch_address.length = sizeof(uint32_t);
403 
404     scmi_perf_ctx.domain_ctx_table = &domain0_ctx;
405 #endif
406     fwk_id_t service_id =
407         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
408 
409     struct scmi_perf_describe_fc_a2p payload = {
410         .domain_id = 0,
411         .message_id = MOD_SCMI_PERF_LEVEL_GET,
412     };
413 
414     mod_scmi_from_protocol_api_respond_Stub(
415         describe_fast_channels_valid_params_respond_callback);
416     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
417         SCMI_SUCCESS);
418     status = to_protocol_api->message_handler(
419         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
420         service_id,
421         (const uint32_t *)&payload,
422         payload_size_table[MOD_SCMI_PERF_DESCRIBE_FAST_CHANNEL],
423         MOD_SCMI_PERF_DESCRIBE_FAST_CHANNEL);
424 
425     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
426 }
427 
428 /*
429  * Test the scmi_perf_describe_fast_channels function with an invalid
430  * domain_id.
431  */
describe_fast_channels_invalid_domain_id_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)432 int describe_fast_channels_invalid_domain_id_respond_callback(
433     fwk_id_t service_id,
434     const void *payload,
435     size_t size,
436     int NumCalls)
437 {
438     struct scmi_perf_describe_fc_p2a *return_values =
439         (struct scmi_perf_describe_fc_p2a *)payload;
440 
441     TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_FOUND, return_values->status);
442 
443     return FWK_SUCCESS;
444 }
445 
utest_scmi_perf_describe_fast_channels_invalid_domain_id(void)446 void utest_scmi_perf_describe_fast_channels_invalid_domain_id(void)
447 {
448     int status;
449 
450     fwk_id_t service_id =
451         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
452 
453     struct scmi_perf_describe_fc_a2p payload = {
454         .domain_id = scmi_perf_ctx.domain_count,
455         .message_id = MOD_SCMI_PERF_LEVEL_GET,
456     };
457 
458     mod_scmi_from_protocol_api_respond_Stub(
459         describe_fast_channels_invalid_domain_id_respond_callback);
460     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
461         SCMI_SUCCESS);
462     status = to_protocol_api->message_handler(
463         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
464         service_id,
465         (const uint32_t *)&payload,
466         payload_size_table[MOD_SCMI_PERF_DESCRIBE_FAST_CHANNEL],
467         MOD_SCMI_PERF_DESCRIBE_FAST_CHANNEL);
468 
469     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
470 }
471 
472 /*
473  * Test the scmi_perf_describe_fast_channels function with an invalid
474  * message_id.
475  */
describe_fast_channels_invalid_message_id_respond_callback(fwk_id_t service_id,const void * payload,size_t size,int NumCalls)476 int describe_fast_channels_invalid_message_id_respond_callback(
477     fwk_id_t service_id,
478     const void *payload,
479     size_t size,
480     int NumCalls)
481 {
482     struct scmi_perf_describe_fc_p2a *return_values =
483         (struct scmi_perf_describe_fc_p2a *)payload;
484 
485     TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_FOUND, return_values->status);
486 
487     return FWK_SUCCESS;
488 }
489 
utest_scmi_perf_describe_fast_channels_invalid_message_id(void)490 void utest_scmi_perf_describe_fast_channels_invalid_message_id(void)
491 {
492     int status;
493 
494     fwk_id_t service_id =
495         FWK_ID_ELEMENT_INIT(TEST_MODULE_IDX, TEST_SCMI_AGENT_IDX_0);
496 
497     struct scmi_perf_describe_fc_a2p payload = {
498         .domain_id = 0,
499         .message_id = MOD_SCMI_PERF_COMMAND_COUNT,
500     };
501 
502     mod_scmi_from_protocol_api_respond_Stub(
503         describe_fast_channels_invalid_message_id_respond_callback);
504     mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn(
505         SCMI_SUCCESS);
506     status = to_protocol_api->message_handler(
507         (fwk_id_t)MOD_SCMI_PROTOCOL_ID_PERF,
508         service_id,
509         (const uint32_t *)&payload,
510         payload_size_table[MOD_SCMI_PERF_DESCRIBE_FAST_CHANNEL],
511         MOD_SCMI_PERF_DESCRIBE_FAST_CHANNEL);
512 
513     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
514 }
515 
utest_perf_fch_init_success(void)516 void utest_perf_fch_init_success(void)
517 {
518     unsigned int element_count = 0;
519     const void *data = NULL;
520     struct mod_scmi_perf_private_api_perf_stub api;
521     int status;
522 
523     struct mod_scmi_perf_config config = {
524         .fast_channels_rate_limit = SCMI_PERF_FC_MIN_RATE_LIMIT / 2,
525     };
526     perf_fch_ctx.perf_ctx->config = &config;
527 
528     status = perf_fch_init(
529         fwk_module_id_scmi_perf, element_count, data, &scmi_perf_ctx, &api);
530     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
531     TEST_ASSERT_EQUAL(&scmi_perf_ctx, perf_fch_ctx.perf_ctx);
532     TEST_ASSERT_EQUAL(&api, perf_fch_ctx.api_fch_stub);
533     TEST_ASSERT_EQUAL(
534         SCMI_PERF_FC_MIN_RATE_LIMIT, perf_fch_ctx.fast_channels_rate_limit);
535 }
536 
scmi_perf_fch_test_main(void)537 int scmi_perf_fch_test_main(void)
538 {
539     UNITY_BEGIN();
540 
541     RUN_TEST(utest_scmi_perf_protocol_message_attributes_handler_valid_param);
542     RUN_TEST(utest_scmi_perf_protocol_message_attributes_handler_invalid_param);
543 
544     RUN_TEST(utest_scmi_perf_domain_attributes_handler_valid_param);
545     RUN_TEST(utest_scmi_perf_domain_attributes_handler_invalid_param);
546 
547     RUN_TEST(utest_scmi_perf_describe_fast_channels_valid_params);
548     RUN_TEST(utest_scmi_perf_describe_fast_channels_invalid_domain_id);
549     RUN_TEST(utest_scmi_perf_describe_fast_channels_invalid_message_id);
550 
551     RUN_TEST(utest_perf_fch_init_success);
552 
553     return UNITY_END();
554 }
555 
556 #if !defined(TEST_ON_TARGET)
main(void)557 int main(void)
558 {
559     return scmi_perf_fch_test_main();
560 }
561 #endif
562