LCOV - code coverage report
Current view: top level - unit_test/test_spdm_responder - test_spdm_responder.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 51.8 % 83 43
Test Date: 2025-08-24 08:11:14 Functions: 100.0 % 1 1

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-2025 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "spdm_unit_test.h"
       8              : #include "internal/libspdm_responder_lib.h"
       9              : 
      10              : int libspdm_responder_version_test_main(void);
      11              : int libspdm_responder_capabilities_test_main(void);
      12              : int libspdm_responder_algorithms_test_main(void);
      13              : 
      14              : #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
      15              : int libspdm_responder_digests_test_main(void);
      16              : int libspdm_responder_certificate_test_main(void);
      17              : #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP*/
      18              : 
      19              : #if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP
      20              : int libspdm_responder_challenge_auth_test_main(void);
      21              : #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP*/
      22              : 
      23              : #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
      24              : int libspdm_responder_measurements_test_main(void);
      25              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
      26              : 
      27              : #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP
      28              : int libspdm_responder_endpoint_info_test_main(void);
      29              : int libspdm_responder_endpoint_info_error_test_main(void);
      30              : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP*/
      31              : 
      32              : #if LIBSPDM_ENABLE_CAPABILITY_MEL_CAP
      33              : int libspdm_responder_measurement_extension_log_test_main(void);
      34              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP*/
      35              : 
      36              : #if LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP
      37              : int libspdm_responder_key_pair_info_test_main(void);
      38              : #endif /* LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP*/
      39              : 
      40              : #if LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP
      41              : int libspdm_responder_set_key_pair_info_ack_test_main(void);
      42              : #endif /* LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP*/
      43              : 
      44              : #if LIBSPDM_RESPOND_IF_READY_SUPPORT
      45              : #if (LIBSPDM_ENABLE_CAPABILITY_CERT_CAP || LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP || \
      46              :      LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP || LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP || \
      47              :      LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
      48              : int libspdm_responder_respond_if_ready_test_main (void);
      49              : #endif /* LIBSPDM_ENABLE_CAPABILITY_*_CAP */
      50              : #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
      51              : 
      52              : #if LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP
      53              : int libspdm_responder_key_exchange_test_main(void);
      54              : #endif /* LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP*/
      55              : 
      56              : int libspdm_responder_finish_test_main(void);
      57              : 
      58              : #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
      59              : int libspdm_responder_psk_exchange_test_main(void);
      60              : int libspdm_responder_psk_finish_test_main(void);
      61              : #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP */
      62              : 
      63              : #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
      64              : int libspdm_responder_heartbeat_test_main(void);
      65              : int libspdm_responder_key_update_test_main(void);
      66              : int libspdm_responder_end_session_test_main(void);
      67              : #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
      68              : 
      69              : #if LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP
      70              : #if LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP
      71              : #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
      72              : int spdm_responder_encap_get_digests_test_main(void);
      73              : int spdm_responder_encap_get_certificate_test_main(void);
      74              : #endif /* LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT */
      75              : #if LIBSPDM_SEND_CHALLENGE_SUPPORT
      76              : int libspdm_responder_encap_challenge_auth_test_main(void);
      77              : #endif /* LIBSPDM_SEND_CHALLENGE_SUPPORT */
      78              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP */
      79              : int libspdm_responder_encapsulated_response_test_main(void);
      80              : int libspdm_responder_encap_key_update_test_main(void);
      81              : #if LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT
      82              : int libspdm_responder_encap_get_endpoint_info_test_main(void);
      83              : int libspdm_responder_encap_get_endpoint_info_error_test_main(void);
      84              : #endif /* LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT */
      85              : #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
      86              : int libspdm_responder_encap_send_event_test_main(void);
      87              : int libspdm_responder_encap_send_event_error_test_main(void);
      88              : #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
      89              : #endif /* LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP*/
      90              : 
      91              : int libspdm_responder_set_certificate_rsp_test_main(void);
      92              : int libspdm_responder_csr_test_main(void);
      93              : 
      94              : #if LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP
      95              : int libspdm_responder_chunk_get_rsp_test_main(void);
      96              : int libspdm_responder_receive_send_test_main(void);
      97              : int libspdm_responder_chunk_send_ack_test_main(void);
      98              : #endif /* LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP */
      99              : 
     100              : #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
     101              : int libspdm_responder_supported_event_types_test_main(void);
     102              : int libspdm_responder_supported_event_types_error_test_main(void);
     103              : int libspdm_responder_subscribe_event_types_ack_test_main(void);
     104              : int libspdm_responder_subscribe_event_types_ack_error_test_main(void);
     105              : #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
     106              : 
     107              : #if LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES
     108              : int libspdm_responder_vendor_cmds_test_main(void);
     109              : int libspdm_responder_vendor_cmds_error_test_main(void);
     110              : #endif /* LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES */
     111              : 
     112            1 : int main(void)
     113              : {
     114            1 :     int return_value = 0;
     115              : 
     116            1 :     if (libspdm_responder_version_test_main() != 0) {
     117            0 :         return_value = 1;
     118              :     }
     119              : 
     120            1 :     if (libspdm_responder_capabilities_test_main() != 0) {
     121            0 :         return_value = 1;
     122              :     }
     123              : 
     124            1 :     if (libspdm_responder_algorithms_test_main() != 0) {
     125            0 :         return_value = 1;
     126              :     }
     127              : 
     128              :     #if LIBSPDM_ENABLE_CAPABILITY_CERT_CAP
     129            1 :     if (libspdm_responder_digests_test_main() != 0) {
     130            0 :         return_value = 1;
     131              :     }
     132            1 :     if (libspdm_responder_certificate_test_main() != 0) {
     133            0 :         return_value = 1;
     134              :     }
     135              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_CERT_CAP*/
     136              : 
     137              :     #if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP
     138            1 :     if (libspdm_responder_challenge_auth_test_main() != 0) {
     139            0 :         return_value = 1;
     140              :     }
     141              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP*/
     142              : 
     143              :     #if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP
     144            1 :     if (libspdm_responder_measurements_test_main() != 0) {
     145            0 :         return_value = 1;
     146              :     }
     147              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP*/
     148              : 
     149              :     #if LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP
     150            1 :     if (libspdm_responder_endpoint_info_test_main() != 0) {
     151            0 :         return_value = 1;
     152              :     }
     153            1 :     if (libspdm_responder_endpoint_info_error_test_main() != 0) {
     154            0 :         return_value = 1;
     155              :     }
     156              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP*/
     157              : 
     158              :     #if LIBSPDM_ENABLE_CAPABILITY_MEL_CAP
     159            1 :     if (libspdm_responder_measurement_extension_log_test_main() != 0) {
     160            0 :         return_value = 1;
     161              :     }
     162              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP*/
     163              : 
     164              :     #if LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP
     165            1 :     if (libspdm_responder_key_pair_info_test_main() != 0) {
     166            0 :         return_value = 1;
     167              :     }
     168              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP*/
     169              : 
     170              :     #if LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP
     171            1 :     if (libspdm_responder_set_key_pair_info_ack_test_main() != 0) {
     172            0 :         return_value = 1;
     173              :     }
     174              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP*/
     175              : 
     176              :     #if LIBSPDM_RESPOND_IF_READY_SUPPORT
     177              :     #if (LIBSPDM_ENABLE_CAPABILITY_CERT_CAP || LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP || \
     178              :          LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP || LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP || \
     179              :          LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
     180            1 :     if (libspdm_responder_respond_if_ready_test_main() != 0) {
     181            0 :         return_value = 1;
     182              :     }
     183              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_*_CAP */
     184              :     #endif /* LIBSPDM_RESPOND_IF_READY_SUPPORT */
     185              : 
     186              :     #if LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP
     187            1 :     if (libspdm_responder_key_exchange_test_main() != 0) {
     188            0 :         return_value = 1;
     189              :     }
     190              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP*/
     191              : 
     192              :     #if LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP
     193            1 :     if (libspdm_responder_finish_test_main() != 0) {
     194            0 :         return_value = 1;
     195              :     }
     196              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP*/
     197              : 
     198              :     #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
     199            1 :     if (libspdm_responder_psk_exchange_test_main() != 0) {
     200            0 :         return_value = 1;
     201              :     }
     202              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP*/
     203              : 
     204              :     #if LIBSPDM_ENABLE_CAPABILITY_PSK_CAP
     205            1 :     if (libspdm_responder_psk_finish_test_main() != 0) {
     206            0 :         return_value = 1;
     207              :     }
     208              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_PSK_CAP*/
     209              : 
     210              :     #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
     211            1 :     if (libspdm_responder_heartbeat_test_main() != 0) {
     212            0 :         return_value = 1;
     213              :     }
     214            1 :     if (libspdm_responder_key_update_test_main() != 0) {
     215            0 :         return_value = 1;
     216              :     }
     217            1 :     if (libspdm_responder_end_session_test_main() != 0) {
     218            0 :         return_value = 1;
     219              :     }
     220              :     #endif /* (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP) */
     221              : 
     222              :     #if LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP
     223              :     #if LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP
     224              :     #if LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT
     225            1 :     if (spdm_responder_encap_get_digests_test_main() != 0) {
     226            0 :         return_value = 1;
     227              :     }
     228            1 :     if (spdm_responder_encap_get_certificate_test_main() != 0) {
     229            0 :         return_value = 1;
     230              :     }
     231              :     #endif /* LIBSPDM_SEND_GET_CERTIFICATE_SUPPORT */
     232              :     #if LIBSPDM_SEND_CHALLENGE_SUPPORT
     233            1 :     if (libspdm_responder_encap_challenge_auth_test_main() != 0) {
     234            0 :         return_value = 1;
     235              :     }
     236              :     #endif /* LIBSPDM_SEND_CHALLENGE_SUPPORT */
     237              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP */
     238            1 :     if (libspdm_responder_encapsulated_response_test_main() != 0) {
     239            0 :         return_value = 1;
     240              :     }
     241            1 :     if (libspdm_responder_encap_key_update_test_main() != 0) {
     242            0 :         return_value = 1;
     243              :     }
     244              :     #if LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT
     245            1 :     if (libspdm_responder_encap_get_endpoint_info_test_main() != 0) {
     246            0 :         return_value = 1;
     247              :     }
     248            1 :     if (libspdm_responder_encap_get_endpoint_info_error_test_main() != 0) {
     249            0 :         return_value = 1;
     250              :     }
     251              :     #endif /* LIBSPDM_SEND_GET_ENDPOINT_INFO_SUPPORT */
     252              :     #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
     253            1 :     if (libspdm_responder_encap_send_event_test_main() != 0) {
     254            0 :         return_value = 1;
     255              :     }
     256            1 :     if (libspdm_responder_encap_send_event_error_test_main() != 0) {
     257            0 :         return_value = 1;
     258              :     }
     259              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
     260              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_ENCAP_CAP*/
     261              : 
     262              :     #if LIBSPDM_ENABLE_CAPABILITY_SET_CERT_CAP
     263            1 :     if (libspdm_responder_set_certificate_rsp_test_main() != 0) {
     264            0 :         return_value = 1;
     265              :     }
     266              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_SET_CERT_CAP */
     267              : 
     268              :     #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP
     269            1 :     if (libspdm_responder_csr_test_main() != 0) {
     270            0 :         return_value = 1;
     271              :     }
     272              :     #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP*/
     273              : 
     274              :     #if LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP
     275            1 :     if (libspdm_responder_chunk_get_rsp_test_main() != 0) {
     276            0 :         return_value = 1;
     277              :     }
     278              : 
     279            1 :     if (libspdm_responder_receive_send_test_main() != 0) {
     280            0 :         return_value = 1;
     281              :     }
     282              : 
     283            1 :     if (libspdm_responder_chunk_send_ack_test_main() != 0) {
     284            0 :         return_value = 1;
     285              :     }
     286              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_CHUNK_CAP */
     287              : 
     288              :     #if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP
     289            1 :     if (libspdm_responder_supported_event_types_test_main() != 0) {
     290            0 :         return_value = 1;
     291              :     }
     292            1 :     if (libspdm_responder_supported_event_types_error_test_main() != 0) {
     293            0 :         return_value = 1;
     294              :     }
     295            1 :     if (libspdm_responder_subscribe_event_types_ack_test_main() != 0) {
     296            0 :         return_value = 1;
     297              :     }
     298            1 :     if (libspdm_responder_subscribe_event_types_ack_error_test_main() != 0) {
     299            0 :         return_value = 1;
     300              :     }
     301              :     #endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */
     302              : 
     303              :     #if LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES
     304            1 :     if (libspdm_responder_vendor_cmds_test_main() != 0) {
     305            0 :         return_value = 1;
     306              :     }
     307            1 :     if (libspdm_responder_vendor_cmds_error_test_main() != 0) {
     308            0 :         return_value = 1;
     309              :     }
     310              :     #endif /* LIBSPDM_ENABLE_VENDOR_DEFINED_MESSAGES */
     311              : 
     312            1 :     return return_value;
     313              : }
        

Generated by: LCOV version 2.0-1