LCOV - code coverage report
Current view: top level - unit_test/test_spdm_responder - event_ack.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 98.7 % 237 234
Test Date: 2025-10-12 08:10:56 Functions: 100.0 % 7 7

            Line data    Source code
       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 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              : #include "internal/libspdm_secured_message_lib.h"
      10              : 
      11              : #if LIBSPDM_EVENT_RECIPIENT_SUPPORT
      12              : 
      13              : static uint8_t m_spdm_request_buffer[0x1000];
      14              : static uint8_t m_spdm_response_buffer[0x1000];
      15              : 
      16              : static const uint32_t m_session_id = 0xffffffff;
      17              : 
      18              : typedef struct {
      19              :     uint32_t event_instance_id;
      20              :     uint8_t svh_id;
      21              :     uint8_t svh_vendor_id_len;
      22              :     uint8_t svh_vendor_id[4];
      23              :     uint16_t event_type_id;
      24              :     uint16_t event_detail_len;
      25              :     uint8_t event_detail[100];
      26              : } expected_event_t;
      27              : 
      28              : static expected_event_t m_expected_event[4];
      29              : static uint32_t m_event_counter;
      30              : 
      31            9 : static libspdm_return_t process_event(void *spdm_context,
      32              :                                       uint32_t session_id,
      33              :                                       uint32_t event_instance_id,
      34              :                                       uint8_t svh_id,
      35              :                                       uint8_t svh_vendor_id_len,
      36              :                                       const void *svh_vendor_id,
      37              :                                       uint16_t event_type_id,
      38              :                                       uint16_t event_detail_len,
      39              :                                       const void *event_detail)
      40              : {
      41            9 :     printf("Event Received\n");
      42            9 :     printf("Event Instance ID = [0x%x]\n", event_instance_id);
      43            9 :     printf("SVH ID = [0x%x], SVH VendorIDLen = [0x%x]\n", svh_id, svh_vendor_id_len);
      44            9 :     if (svh_vendor_id_len != 0) {
      45            0 :         printf("SVH VendorID\n");
      46            0 :         libspdm_dump_hex(svh_vendor_id, svh_vendor_id_len);
      47            0 :         printf("\n");
      48              :     }
      49            9 :     printf("EventTypeID = [0x%x], EventDetailLen = [0x%x]\n", event_type_id, event_detail_len);
      50            9 :     printf("Event Detail\n");
      51            9 :     libspdm_dump_hex(event_detail, event_detail_len);
      52              : 
      53            9 :     assert_int_equal(session_id, m_session_id);
      54            9 :     assert_int_equal(event_instance_id, m_expected_event[m_event_counter].event_instance_id);
      55            9 :     assert_int_equal(event_type_id, m_expected_event[m_event_counter].event_type_id);
      56            9 :     assert_int_equal(svh_id, m_expected_event[m_event_counter].svh_id);
      57            9 :     assert_int_equal(svh_vendor_id_len, m_expected_event[m_event_counter].svh_vendor_id_len);
      58            9 :     if (svh_vendor_id_len == 0) {
      59            9 :         assert_ptr_equal(svh_vendor_id, NULL);
      60              :     }
      61            9 :     assert_int_equal(event_detail_len, m_expected_event[m_event_counter].event_detail_len);
      62            9 :     assert_memory_equal(m_expected_event[m_event_counter].event_detail, event_detail,
      63              :                         event_detail_len);
      64            9 :     m_event_counter++;
      65              : 
      66            9 :     return LIBSPDM_STATUS_SUCCESS;
      67              : }
      68              : 
      69            4 : static void set_standard_state(libspdm_context_t *spdm_context)
      70              : {
      71              :     libspdm_session_info_t *session_info;
      72              : 
      73            4 :     spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
      74              :                                             SPDM_VERSION_NUMBER_SHIFT_BIT;
      75            4 :     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
      76              : 
      77            4 :     spdm_context->connection_info.capability.flags |=
      78              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_EVENT_CAP;
      79            4 :     spdm_context->connection_info.capability.flags |=
      80              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
      81            4 :     spdm_context->connection_info.capability.flags |=
      82              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
      83            4 :     spdm_context->connection_info.capability.flags |=
      84              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
      85            4 :     spdm_context->connection_info.capability.flags |=
      86              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
      87              : 
      88            4 :     spdm_context->local_context.capability.flags |=
      89              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
      90            4 :     spdm_context->local_context.capability.flags |=
      91              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
      92            4 :     spdm_context->local_context.capability.flags |=
      93              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
      94            4 :     spdm_context->local_context.capability.flags |=
      95              :         SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP;
      96              : 
      97            4 :     spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
      98            4 :     spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
      99            4 :     spdm_context->connection_info.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
     100            4 :     spdm_context->connection_info.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
     101              : 
     102            4 :     spdm_context->latest_session_id = m_session_id;
     103            4 :     spdm_context->last_spdm_request_session_id_valid = true;
     104            4 :     spdm_context->last_spdm_request_session_id = m_session_id;
     105            4 :     session_info = &spdm_context->session_info[0];
     106            4 :     libspdm_session_info_init(spdm_context, session_info, m_session_id,
     107              :                               SECURED_SPDM_VERSION_11 << SPDM_VERSION_NUMBER_SHIFT_BIT, true);
     108            4 :     libspdm_secured_message_set_session_state(
     109              :         session_info->secured_message_context,
     110              :         LIBSPDM_SESSION_STATE_ESTABLISHED);
     111              : 
     112            4 :     libspdm_register_event_callback(spdm_context, process_event);
     113            4 : }
     114              : 
     115              : /**
     116              :  * Test 1: Send exactly one event.
     117              :  * Expected behavior: Event is handled by process_event and one event is registered.
     118              :  **/
     119            1 : static void rsp_event_ack_case1(void **state)
     120              : {
     121              :     libspdm_return_t status;
     122              :     libspdm_test_context_t *spdm_test_context;
     123              :     libspdm_context_t *spdm_context;
     124              :     spdm_send_event_request_t *send_event;
     125              :     size_t request_size;
     126              :     spdm_event_ack_response_t *event_ack;
     127            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     128              :     uint8_t event_data_size;
     129              :     spdm_dmtf_event_type_event_lost_t event_lost;
     130              : 
     131            1 :     spdm_test_context = *state;
     132            1 :     spdm_context = spdm_test_context->spdm_context;
     133            1 :     spdm_test_context->case_id = 0x1;
     134              : 
     135            1 :     set_standard_state(spdm_context);
     136              : 
     137            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     138              : 
     139            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     140            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     141            1 :     send_event->header.param1 = 0;
     142            1 :     send_event->header.param2 = 0;
     143            1 :     send_event->event_count = 1;
     144              : 
     145            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     146            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     147              : 
     148            1 :     generate_dmtf_event_data(send_event + 1, &event_data_size, 0x11223344,
     149              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     150              : 
     151            1 :     m_event_counter = 0;
     152            1 :     m_expected_event[0].event_instance_id = 0x11223344;
     153            1 :     m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
     154            1 :     m_expected_event[0].svh_vendor_id_len = 0;
     155            1 :     m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
     156            1 :     m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
     157            1 :     memcpy(m_expected_event[0].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
     158              : 
     159            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size;
     160              : 
     161            1 :     status = libspdm_get_response_send_event(
     162              :         spdm_context, request_size, m_spdm_request_buffer,
     163              :         &response_size, m_spdm_response_buffer);
     164              : 
     165            1 :     event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
     166              : 
     167            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     168              : 
     169            1 :     assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
     170            1 :     assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     171            1 :     assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
     172            1 :     assert_int_equal(event_ack->header.param1, 0);
     173            1 :     assert_int_equal(event_ack->header.param2, 0);
     174              : 
     175            1 :     assert_int_equal(m_event_counter, 1);
     176            1 : }
     177              : 
     178              : /**
     179              :  * Test 2: Send two events with in-order event instance IDs.
     180              :  * Expected behavior: Events are handled by process_event and two events are registered.
     181              :  **/
     182            1 : static void rsp_event_ack_case2(void **state)
     183              : {
     184              :     libspdm_return_t status;
     185              :     libspdm_test_context_t *spdm_test_context;
     186              :     libspdm_context_t *spdm_context;
     187              :     spdm_send_event_request_t *send_event;
     188              :     size_t request_size;
     189              :     spdm_event_ack_response_t *event_ack;
     190            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     191              :     uint8_t event_data_size[2];
     192              :     spdm_dmtf_event_type_event_lost_t event_lost;
     193              :     spdm_dmtf_event_type_certificate_changed_t certificate_changed;
     194              :     uint8_t *ptr;
     195              : 
     196            1 :     spdm_test_context = *state;
     197            1 :     spdm_context = spdm_test_context->spdm_context;
     198            1 :     spdm_test_context->case_id = 0x02;
     199              : 
     200            1 :     set_standard_state(spdm_context);
     201              : 
     202            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     203              : 
     204            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     205            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     206            1 :     send_event->header.param1 = 0;
     207            1 :     send_event->header.param2 = 0;
     208            1 :     send_event->event_count = 2;
     209              : 
     210            1 :     certificate_changed.certificate_changed = 5;
     211              : 
     212            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     213            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     214              : 
     215            1 :     ptr = (uint8_t *)(send_event + 1);
     216              : 
     217            1 :     generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
     218              :                              SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
     219            1 :     ptr += event_data_size[0];
     220              : 
     221            1 :     generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223344,
     222              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     223            1 :     ptr += event_data_size[1];
     224              : 
     225            1 :     m_event_counter = 0;
     226              : 
     227            1 :     m_expected_event[0].event_instance_id = 0x11223343;
     228            1 :     m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
     229            1 :     m_expected_event[0].svh_vendor_id_len = 0;
     230            1 :     m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
     231            1 :     m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
     232            1 :     memcpy(m_expected_event[0].event_detail, &certificate_changed,
     233              :            SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
     234              : 
     235            1 :     m_expected_event[1].event_instance_id = 0x11223344;
     236            1 :     m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
     237            1 :     m_expected_event[1].svh_vendor_id_len = 0;
     238            1 :     m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
     239            1 :     m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
     240            1 :     memcpy(m_expected_event[1].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
     241              : 
     242            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
     243              : 
     244            1 :     status = libspdm_get_response_send_event(
     245              :         spdm_context, request_size, m_spdm_request_buffer,
     246              :         &response_size, m_spdm_response_buffer);
     247              : 
     248            1 :     event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
     249              : 
     250            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     251              : 
     252            1 :     assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
     253            1 :     assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     254            1 :     assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
     255            1 :     assert_int_equal(event_ack->header.param1, 0);
     256            1 :     assert_int_equal(event_ack->header.param2, 0);
     257              : 
     258            1 :     assert_int_equal(m_event_counter, 2);
     259            1 : }
     260              : 
     261              : /**
     262              :  * Test 3: Send two events with out-of-order event instance IDs.
     263              :  * Expected behavior: Events are handled by process_event and two events are registered.
     264              :  **/
     265            1 : static void rsp_event_ack_case3(void **state)
     266              : {
     267              :     libspdm_return_t status;
     268              :     libspdm_test_context_t *spdm_test_context;
     269              :     libspdm_context_t *spdm_context;
     270              :     spdm_send_event_request_t *send_event;
     271              :     size_t request_size;
     272              :     spdm_event_ack_response_t *event_ack;
     273            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     274              :     uint8_t event_data_size[2];
     275              :     spdm_dmtf_event_type_event_lost_t event_lost;
     276              :     spdm_dmtf_event_type_certificate_changed_t certificate_changed;
     277              :     uint8_t *ptr;
     278              : 
     279            1 :     spdm_test_context = *state;
     280            1 :     spdm_context = spdm_test_context->spdm_context;
     281            1 :     spdm_test_context->case_id = 0x03;
     282              : 
     283            1 :     set_standard_state(spdm_context);
     284              : 
     285            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     286              : 
     287            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     288            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     289            1 :     send_event->header.param1 = 0;
     290            1 :     send_event->header.param2 = 0;
     291            1 :     send_event->event_count = 2;
     292              : 
     293            1 :     certificate_changed.certificate_changed = 5;
     294              : 
     295            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     296            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     297              : 
     298            1 :     ptr = (uint8_t *)(send_event + 1);
     299              : 
     300            1 :     generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223344,
     301              :                              SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
     302            1 :     ptr += event_data_size[0];
     303              : 
     304            1 :     generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223343,
     305              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     306            1 :     ptr += event_data_size[1];
     307              : 
     308            1 :     m_event_counter = 0;
     309              : 
     310            1 :     m_expected_event[0].event_instance_id = 0x11223343;
     311            1 :     m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
     312            1 :     m_expected_event[0].svh_vendor_id_len = 0;
     313            1 :     m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
     314            1 :     m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
     315            1 :     memcpy(m_expected_event[0].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
     316              : 
     317            1 :     m_expected_event[1].event_instance_id = 0x11223344;
     318            1 :     m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
     319            1 :     m_expected_event[1].svh_vendor_id_len = 0;
     320            1 :     m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
     321            1 :     m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
     322            1 :     memcpy(m_expected_event[1].event_detail, &certificate_changed,
     323              :            SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
     324              : 
     325            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1];
     326              : 
     327            1 :     status = libspdm_get_response_send_event(
     328              :         spdm_context, request_size, m_spdm_request_buffer,
     329              :         &response_size, m_spdm_response_buffer);
     330              : 
     331            1 :     event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
     332              : 
     333            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     334              : 
     335            1 :     assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
     336            1 :     assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     337            1 :     assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
     338            1 :     assert_int_equal(event_ack->header.param1, 0);
     339            1 :     assert_int_equal(event_ack->header.param2, 0);
     340              : 
     341            1 :     assert_int_equal(m_event_counter, 2);
     342            1 : }
     343              : 
     344              : /**
     345              :  * Test 4: Send four events with in-order event instance IDs.
     346              :  * Expected behavior: Events are handled by process_event and four events are registered.
     347              :  **/
     348            1 : static void rsp_event_ack_case4(void **state)
     349              : {
     350              :     libspdm_return_t status;
     351              :     libspdm_test_context_t *spdm_test_context;
     352              :     libspdm_context_t *spdm_context;
     353              :     spdm_send_event_request_t *send_event;
     354              :     size_t request_size;
     355              :     spdm_event_ack_response_t *event_ack;
     356            1 :     size_t response_size =  sizeof(m_spdm_response_buffer);
     357              :     uint8_t event_data_size[4];
     358              :     spdm_dmtf_event_type_event_lost_t event_lost;
     359              :     spdm_dmtf_event_type_certificate_changed_t certificate_changed;
     360              :     spdm_dmtf_event_type_measurement_changed_t measurement_changed;
     361              :     spdm_dmtf_event_type_measurement_pre_update_t measurement_pre_update;
     362              :     uint8_t *ptr;
     363              :     uint32_t index;
     364              : 
     365            1 :     spdm_test_context = *state;
     366            1 :     spdm_context = spdm_test_context->spdm_context;
     367            1 :     spdm_test_context->case_id = 0x04;
     368              : 
     369            1 :     set_standard_state(spdm_context);
     370              : 
     371            1 :     send_event = (spdm_send_event_request_t *)m_spdm_request_buffer;
     372              : 
     373            1 :     send_event->header.spdm_version = SPDM_MESSAGE_VERSION_13;
     374            1 :     send_event->header.request_response_code = SPDM_SEND_EVENT;
     375            1 :     send_event->header.param1 = 0;
     376            1 :     send_event->header.param2 = 0;
     377            1 :     send_event->event_count = 4;
     378              : 
     379            1 :     ptr = (uint8_t *)(send_event + 1);
     380              : 
     381            1 :     certificate_changed.certificate_changed = 5;
     382            1 :     generate_dmtf_event_data(ptr, &event_data_size[0], 0x11223343,
     383              :                              SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED, &certificate_changed);
     384            1 :     ptr += event_data_size[0];
     385              : 
     386            1 :     event_lost.last_acked_event_inst_id = 0xffeeddcc;
     387            1 :     event_lost.last_lost_event_inst_id = 0x55667788;
     388            1 :     generate_dmtf_event_data(ptr, &event_data_size[1], 0x11223344,
     389              :                              SPDM_DMTF_EVENT_TYPE_EVENT_LOST, &event_lost);
     390            1 :     ptr += event_data_size[1];
     391              : 
     392           33 :     for (index = 0; index < SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE; index++) {
     393           32 :         measurement_changed.changed_measurements[index] = (uint8_t)index;
     394              :     }
     395            1 :     generate_dmtf_event_data(ptr, &event_data_size[2], 0x11223345,
     396              :                              SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED, &measurement_changed);
     397            1 :     ptr += event_data_size[2];
     398              : 
     399           33 :     for (index = 0; index < SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE; index++) {
     400           32 :         measurement_pre_update.pre_update_measurement_changes[index] = (uint8_t)(2 * index);
     401              :     }
     402            1 :     generate_dmtf_event_data(ptr, &event_data_size[3], 0x11223346,
     403              :                              SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE, &measurement_pre_update);
     404            1 :     ptr += event_data_size[3];
     405              : 
     406            1 :     m_event_counter = 0;
     407              : 
     408            1 :     m_expected_event[0].event_instance_id = 0x11223343;
     409            1 :     m_expected_event[0].svh_id = SPDM_REGISTRY_ID_DMTF;
     410            1 :     m_expected_event[0].svh_vendor_id_len = 0;
     411            1 :     m_expected_event[0].event_type_id = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED;
     412            1 :     m_expected_event[0].event_detail_len = SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE;
     413            1 :     memcpy(m_expected_event[0].event_detail, &certificate_changed,
     414              :            SPDM_DMTF_EVENT_TYPE_CERTIFICATE_CHANGED_SIZE);
     415              : 
     416            1 :     m_expected_event[1].event_instance_id = 0x11223344;
     417            1 :     m_expected_event[1].svh_id = SPDM_REGISTRY_ID_DMTF;
     418            1 :     m_expected_event[1].svh_vendor_id_len = 0;
     419            1 :     m_expected_event[1].event_type_id = SPDM_DMTF_EVENT_TYPE_EVENT_LOST;
     420            1 :     m_expected_event[1].event_detail_len = SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE;
     421            1 :     memcpy(m_expected_event[1].event_detail, &event_lost, SPDM_DMTF_EVENT_TYPE_EVENT_LOST_SIZE);
     422              : 
     423            1 :     m_expected_event[2].event_instance_id = 0x11223345;
     424            1 :     m_expected_event[2].svh_id = SPDM_REGISTRY_ID_DMTF;
     425            1 :     m_expected_event[2].svh_vendor_id_len = 0;
     426            1 :     m_expected_event[2].event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED;
     427            1 :     m_expected_event[2].event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE;
     428            1 :     memcpy(m_expected_event[2].event_detail, &measurement_changed,
     429              :            SPDM_DMTF_EVENT_TYPE_MEASUREMENT_CHANGED_SIZE);
     430              : 
     431            1 :     m_expected_event[3].event_instance_id = 0x11223346;
     432            1 :     m_expected_event[3].svh_id = SPDM_REGISTRY_ID_DMTF;
     433            1 :     m_expected_event[3].svh_vendor_id_len = 0;
     434            1 :     m_expected_event[3].event_type_id = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE;
     435            1 :     m_expected_event[3].event_detail_len = SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE;
     436            1 :     memcpy(m_expected_event[3].event_detail, &measurement_pre_update,
     437              :            SPDM_DMTF_EVENT_TYPE_MEASUREMENT_PRE_UPDATE_SIZE);
     438              : 
     439            1 :     request_size = sizeof(spdm_send_event_request_t) + event_data_size[0] + event_data_size[1] +
     440            1 :                    event_data_size[2] + event_data_size[3];
     441              : 
     442            1 :     status = libspdm_get_response_send_event(
     443              :         spdm_context, request_size, m_spdm_request_buffer,
     444              :         &response_size, m_spdm_response_buffer);
     445              : 
     446            1 :     event_ack = (spdm_event_ack_response_t *)m_spdm_response_buffer;
     447              : 
     448            1 :     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     449              : 
     450            1 :     assert_int_equal(response_size, sizeof(spdm_event_ack_response_t));
     451            1 :     assert_int_equal(event_ack->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     452            1 :     assert_int_equal(event_ack->header.request_response_code, SPDM_EVENT_ACK);
     453            1 :     assert_int_equal(event_ack->header.param1, 0);
     454            1 :     assert_int_equal(event_ack->header.param2, 0);
     455              : 
     456            1 :     assert_int_equal(m_event_counter, 4);
     457            1 : }
     458              : 
     459            1 : int libspdm_rsp_event_ack_test(void)
     460              : {
     461            1 :     const struct CMUnitTest test_cases[] = {
     462              :         cmocka_unit_test(rsp_event_ack_case1),
     463              :         cmocka_unit_test(rsp_event_ack_case2),
     464              :         cmocka_unit_test(rsp_event_ack_case3),
     465              :         cmocka_unit_test(rsp_event_ack_case4),
     466              :     };
     467              : 
     468            1 :     libspdm_test_context_t test_context = {
     469              :         LIBSPDM_TEST_CONTEXT_VERSION,
     470              :         false,
     471              :     };
     472              : 
     473            1 :     libspdm_setup_test_context(&test_context);
     474              : 
     475            1 :     return cmocka_run_group_tests(test_cases,
     476              :                                   libspdm_unit_test_group_setup,
     477              :                                   libspdm_unit_test_group_teardown);
     478              : }
     479              : 
     480              : #endif /* LIBSPDM_EVENT_RECIPIENT_SUPPORT */
        

Generated by: LCOV version 2.0-1