1 #include <libpldm/file.h> 2 #include <libpldm/pldm_types.h> 3 4 #include <array> 5 #include <cstdint> 6 #include <cstring> 7 #include <vector> 8 9 #include "msgbuf.h" 10 11 #include <gmock/gmock.h> 12 #include <gtest/gtest.h> 13 14 #ifdef LIBPLDM_API_TESTING 15 TEST(EncodeDfOpenReq, GoodTest) 16 { 17 uint8_t instance_id = 0; 18 uint16_t file_identifier = 0x0100; 19 bitfield16_t file_attribute; 20 file_attribute.value = 0x0400; 21 std::array<uint8_t, PLDM_DF_OPEN_REQ_BYTES> requestMsg = {0x00, 0x01, 0x00, 22 0x04}; 23 24 const struct pldm_file_df_open_req req_data = {file_identifier, 25 file_attribute}; 26 27 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 28 auto rc = encode_pldm_file_df_open_req(instance_id, &req_data, requestPtr, 29 PLDM_DF_OPEN_REQ_BYTES); 30 31 ASSERT_EQ(rc, 0); 32 EXPECT_EQ( 33 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 34 } 35 #endif 36 37 #ifdef LIBPLDM_API_TESTING 38 TEST(EncodeDfOpenReq, BadTestUnAllocatedPtrParams) 39 { 40 uint8_t instance_id = 0; 41 uint16_t file_identifier = 0x0100; 42 bitfield16_t file_attribute; 43 file_attribute.value = 0x0400; 44 int rc; 45 46 const struct pldm_file_df_open_req req_data = {file_identifier, 47 file_attribute}; 48 49 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 50 rc = encode_pldm_file_df_open_req(instance_id, &req_data, nullptr, 51 PLDM_DF_OPEN_REQ_BYTES); 52 EXPECT_EQ(rc, -EINVAL); 53 54 rc = encode_pldm_file_df_open_req(instance_id, nullptr, requestPtr, 55 PLDM_DF_OPEN_REQ_BYTES); 56 EXPECT_EQ(rc, -EINVAL); 57 } 58 #endif 59 60 #ifdef LIBPLDM_API_TESTING 61 TEST(EncodeDfOpenReq, BadTestInvalidExpectedOutputMsgLength) 62 { 63 uint8_t instance_id = 0; 64 uint16_t file_identifier = 0x0100; 65 bitfield16_t file_attribute; 66 file_attribute.value = 0x0400; 67 int rc; 68 69 const struct pldm_file_df_open_req req_data = {file_identifier, 70 file_attribute}; 71 72 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 73 rc = encode_pldm_file_df_open_req(instance_id, &req_data, requestPtr, 1); 74 EXPECT_EQ(rc, -EOVERFLOW); 75 } 76 #endif 77 78 #ifdef LIBPLDM_API_TESTING 79 TEST(DecodeDfOpenResp, GoodTest) 80 { 81 uint8_t completion_code = PLDM_SUCCESS; 82 uint16_t file_descriptor = 20; 83 84 struct pldm_file_df_open_resp resp_data = {}; 85 86 PLDM_MSGBUF_DEFINE_P(buf); 87 int rc; 88 89 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 90 91 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 92 93 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 94 ASSERT_EQ(rc, 0); 95 96 pldm_msgbuf_insert_uint8(buf, completion_code); 97 pldm_msgbuf_insert_uint16(buf, file_descriptor); 98 99 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 100 101 rc = decode_pldm_file_df_open_resp(responseMsg, payload_length, &resp_data); 102 103 ASSERT_EQ(rc, 0); 104 EXPECT_EQ(resp_data.completion_code, completion_code); 105 EXPECT_EQ(resp_data.file_descriptor, file_descriptor); 106 } 107 #endif 108 109 #ifdef LIBPLDM_API_TESTING 110 TEST(DecodeDfOpenResp, BadTestUnAllocatedPtrParams) 111 { 112 uint8_t completion_code = PLDM_SUCCESS; 113 uint16_t file_descriptor = 20; 114 115 struct pldm_file_df_open_resp resp_data = {}; 116 117 PLDM_MSGBUF_DEFINE_P(buf); 118 int rc; 119 120 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 121 122 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 123 124 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 125 ASSERT_EQ(rc, 0); 126 127 pldm_msgbuf_insert_uint8(buf, completion_code); 128 pldm_msgbuf_insert_uint16(buf, file_descriptor); 129 130 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 131 132 rc = decode_pldm_file_df_open_resp(nullptr, payload_length, &resp_data); 133 EXPECT_EQ(rc, -EINVAL); 134 135 rc = decode_pldm_file_df_open_resp(responseMsg, payload_length, nullptr); 136 EXPECT_EQ(rc, -EINVAL); 137 } 138 #endif 139 140 #ifdef LIBPLDM_API_TESTING 141 TEST(DecodeDfOpenResp, BadTestInvalidExpectedInputMsgLength) 142 { 143 uint8_t completion_code = PLDM_SUCCESS; 144 uint16_t file_descriptor = 20; 145 146 struct pldm_file_df_open_resp resp_data = {}; 147 148 PLDM_MSGBUF_DEFINE_P(buf); 149 int rc; 150 151 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 152 153 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 154 155 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 156 ASSERT_EQ(rc, 0); 157 158 pldm_msgbuf_insert_uint8(buf, completion_code); 159 pldm_msgbuf_insert_uint16(buf, file_descriptor); 160 161 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 162 163 rc = decode_pldm_file_df_open_resp(responseMsg, 0, &resp_data); 164 EXPECT_EQ(rc, -EOVERFLOW); 165 } 166 #endif 167 168 #ifdef LIBPLDM_API_TESTING 169 TEST(EncodeDfCloseReq, GoodTest) 170 { 171 uint8_t instance_id = 0; 172 uint16_t file_descriptor = 0x0200; 173 bitfield16_t df_close_options; 174 df_close_options.value = 0x0100; 175 std::array<uint8_t, PLDM_DF_CLOSE_REQ_BYTES> requestMsg = {0x00, 0x02, 0x00, 176 0x01}; 177 178 const struct pldm_file_df_close_req req_data = {file_descriptor, 179 df_close_options}; 180 181 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 182 auto rc = encode_pldm_file_df_close_req(instance_id, &req_data, requestPtr, 183 PLDM_DF_CLOSE_REQ_BYTES); 184 185 ASSERT_EQ(rc, 0); 186 EXPECT_EQ( 187 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 188 } 189 #endif 190 191 #ifdef LIBPLDM_API_TESTING 192 TEST(EncodeDfCloseReq, BadTestUnAllocatedPtrParams) 193 { 194 uint8_t instance_id = 0; 195 uint16_t file_descriptor = 0x0200; 196 bitfield16_t df_close_options; 197 df_close_options.value = 0x0100; 198 int rc; 199 200 const struct pldm_file_df_close_req req_data = {file_descriptor, 201 df_close_options}; 202 203 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_CLOSE_REQ_BYTES); 204 rc = encode_pldm_file_df_close_req(instance_id, &req_data, nullptr, 205 PLDM_DF_CLOSE_REQ_BYTES); 206 EXPECT_EQ(rc, -EINVAL); 207 208 rc = encode_pldm_file_df_close_req(instance_id, nullptr, requestPtr, 209 PLDM_DF_CLOSE_REQ_BYTES); 210 EXPECT_EQ(rc, -EINVAL); 211 } 212 #endif 213 214 #ifdef LIBPLDM_API_TESTING 215 TEST(EncodeDfCloseReq, BadTestInvalidExpectedOutputMsgLength) 216 { 217 uint8_t instance_id = 0; 218 uint16_t file_descriptor = 0x0200; 219 bitfield16_t df_close_options; 220 df_close_options.value = 0x0100; 221 int rc; 222 223 const struct pldm_file_df_close_req req_data = {file_descriptor, 224 df_close_options}; 225 226 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_CLOSE_REQ_BYTES); 227 rc = encode_pldm_file_df_close_req(instance_id, &req_data, requestPtr, 1); 228 EXPECT_EQ(rc, -EOVERFLOW); 229 } 230 #endif 231 232 #ifdef LIBPLDM_API_TESTING 233 TEST(DecodeDfCloseResp, GoodTest) 234 { 235 uint8_t completion_code = PLDM_SUCCESS; 236 237 struct pldm_file_df_close_resp resp_data = {}; 238 239 PLDM_MSGBUF_DEFINE_P(buf); 240 int rc; 241 242 static constexpr const size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES; 243 244 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 245 246 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 247 ASSERT_EQ(rc, 0); 248 249 pldm_msgbuf_insert_uint8(buf, completion_code); 250 251 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 252 253 rc = 254 decode_pldm_file_df_close_resp(responseMsg, payload_length, &resp_data); 255 256 ASSERT_EQ(rc, 0); 257 EXPECT_EQ(resp_data.completion_code, completion_code); 258 } 259 #endif 260 261 #ifdef LIBPLDM_API_TESTING 262 TEST(DecodeDfCloseResp, BadTestUnAllocatedPtrParams) 263 { 264 uint8_t completion_code = PLDM_SUCCESS; 265 266 struct pldm_file_df_close_resp resp_data = {}; 267 268 PLDM_MSGBUF_DEFINE_P(buf); 269 int rc; 270 271 static constexpr const size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES; 272 273 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 274 275 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 276 ASSERT_EQ(rc, 0); 277 278 pldm_msgbuf_insert_uint8(buf, completion_code); 279 280 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 281 282 rc = decode_pldm_file_df_close_resp(nullptr, payload_length, &resp_data); 283 EXPECT_EQ(rc, -EINVAL); 284 285 rc = decode_pldm_file_df_close_resp(responseMsg, payload_length, nullptr); 286 EXPECT_EQ(rc, -EINVAL); 287 } 288 #endif 289 290 #ifdef LIBPLDM_API_TESTING 291 TEST(EncodeDfHeartbeatReq, GoodTest) 292 { 293 uint8_t instance_id = 0; 294 uint16_t file_descriptor = 0x0200; 295 uint32_t requester_max_interval = 0x88130000; // 5000 ms 296 std::array<uint8_t, PLDM_DF_HEARTBEAT_REQ_BYTES> requestMsg = { 297 0x00, 0x02, 0x00, 0x00, 0x13, 0x88}; 298 299 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor, 300 requester_max_interval}; 301 302 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 303 auto rc = encode_pldm_file_df_heartbeat_req( 304 instance_id, &req_data, requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 305 306 ASSERT_EQ(rc, 0); 307 EXPECT_EQ( 308 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 309 } 310 #endif 311 312 #ifdef LIBPLDM_API_TESTING 313 TEST(EncodeDfHeartbeatReq, BadTestUnAllocatedPtrParams) 314 { 315 uint8_t instance_id = 0; 316 uint16_t file_descriptor = 0x0200; 317 uint32_t requester_max_interval = 0x88130000; // 5000 ms 318 int rc; 319 320 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor, 321 requester_max_interval}; 322 323 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 324 rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, nullptr, 325 PLDM_DF_HEARTBEAT_REQ_BYTES); 326 EXPECT_EQ(rc, -EINVAL); 327 328 rc = encode_pldm_file_df_heartbeat_req(instance_id, nullptr, requestPtr, 329 PLDM_DF_HEARTBEAT_REQ_BYTES); 330 EXPECT_EQ(rc, -EINVAL); 331 } 332 #endif 333 334 #ifdef LIBPLDM_API_TESTING 335 TEST(EncodeDfHeartbeatReq, BadTestInvalidExpectedOutputMsgLength) 336 { 337 uint8_t instance_id = 0; 338 uint16_t file_descriptor = 0x0200; 339 uint32_t requester_max_interval = 0x88130000; // 5000 ms 340 int rc; 341 342 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor, 343 requester_max_interval}; 344 345 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 346 rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, requestPtr, 347 1); 348 EXPECT_EQ(rc, -EOVERFLOW); 349 } 350 #endif 351 352 #ifdef LIBPLDM_API_TESTING 353 TEST(DecodeDfHeartbeatResp, GoodTest) 354 { 355 uint8_t completion_code = PLDM_SUCCESS; 356 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms 357 358 struct pldm_file_df_heartbeat_resp resp_data = {}; 359 360 PLDM_MSGBUF_DEFINE_P(buf); 361 int rc; 362 363 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES; 364 365 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 366 367 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 368 ASSERT_EQ(rc, 0); 369 370 pldm_msgbuf_insert_uint8(buf, completion_code); 371 pldm_msgbuf_insert_uint32(buf, responder_max_interval); 372 373 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 374 375 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length, 376 &resp_data); 377 378 ASSERT_EQ(rc, 0); 379 EXPECT_EQ(resp_data.completion_code, completion_code); 380 EXPECT_EQ(resp_data.responder_max_interval, responder_max_interval); 381 } 382 #endif 383 384 #ifdef LIBPLDM_API_TESTING 385 TEST(DecodeDfHeartbeatResp, BadTestUnAllocatedPtrParams) 386 { 387 uint8_t completion_code = PLDM_SUCCESS; 388 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms 389 390 struct pldm_file_df_heartbeat_resp resp_data = {}; 391 392 PLDM_MSGBUF_DEFINE_P(buf); 393 int rc; 394 395 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES; 396 397 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 398 399 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 400 ASSERT_EQ(rc, 0); 401 402 pldm_msgbuf_insert_uint8(buf, completion_code); 403 pldm_msgbuf_insert_uint32(buf, responder_max_interval); 404 405 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 406 407 rc = 408 decode_pldm_file_df_heartbeat_resp(nullptr, payload_length, &resp_data); 409 EXPECT_EQ(rc, -EINVAL); 410 411 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length, 412 nullptr); 413 EXPECT_EQ(rc, -EINVAL); 414 } 415 #endif 416 417 #ifdef LIBPLDM_API_TESTING 418 TEST(DecodeDfHeartbeatResp, BadTestInvalidExpectedInputMsgLength) 419 { 420 uint8_t completion_code = PLDM_SUCCESS; 421 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms 422 423 struct pldm_file_df_heartbeat_resp resp_data = {}; 424 425 PLDM_MSGBUF_DEFINE_P(buf); 426 int rc; 427 428 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES; 429 430 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 431 432 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 433 ASSERT_EQ(rc, 0); 434 435 pldm_msgbuf_insert_uint8(buf, completion_code); 436 pldm_msgbuf_insert_uint32(buf, responder_max_interval); 437 438 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 439 440 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, 0, &resp_data); 441 EXPECT_EQ(rc, -EOVERFLOW); 442 } 443 #endif 444