libpldm: Fix logical errors between length check and cc decoding
When calling the encode_xxx_resp method in the registration method of
libpldmresponder, if the return value isn't PLDM_SUCCESS, the
payload_length value is only 1(return ccOnlyResponse method) and not a
complete responder data length, so we must first check cc in the
decode_xxx_resp method to avoid logic errors.
if cc != PLDM_SUCCESS, return PLDM_SUCCESS and don't need check
payload_length.
if cc == PLDM_SUCCESS, then check payload_length.
Signed-off-by: George Liu <liuxiwei@inspur.com>
Change-Id: Iaf27c3a6b45638375a4ad1542dd5c4067bbd67b1
diff --git a/libpldm/base.c b/libpldm/base.c
index 0447112..6d9a67f 100644
--- a/libpldm/base.c
+++ b/libpldm/base.c
@@ -179,16 +179,17 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != PLDM_GET_TYPES_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
struct pldm_get_types_resp *response =
(struct pldm_get_types_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- };
memcpy(&(types->byte), response->types, PLDM_MAX_TYPES / 8);
@@ -202,16 +203,17 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != PLDM_GET_COMMANDS_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
struct pldm_get_commands_resp *response =
(struct pldm_get_commands_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- };
memcpy(&(commands->byte), response->commands,
PLDM_MAX_CMDS_PER_TYPE / 8);
@@ -305,16 +307,17 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length < PLDM_GET_VERSION_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
struct pldm_get_version_resp *response =
(struct pldm_get_version_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- };
*next_transfer_handle = le32toh(response->next_transfer_handle);
*transfer_flag = response->transfer_flag;
@@ -366,16 +369,17 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != PLDM_GET_TID_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
struct pldm_get_tid_resp *response =
(struct pldm_get_tid_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- };
*tid = response->tid;
diff --git a/libpldm/base.h b/libpldm/base.h
index d0e917f..bdecc20 100644
--- a/libpldm/base.h
+++ b/libpldm/base.h
@@ -234,6 +234,12 @@
/** @brief Decode a GetPLDMTypes response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
@@ -261,6 +267,12 @@
/** @brief Decode a GetPLDMCommands response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of reponse message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
@@ -293,6 +305,12 @@
/** @brief Decode a GetPLDMVersion response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of reponse message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
@@ -309,6 +327,12 @@
/** @brief Decode a GetTID response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
diff --git a/libpldm/bios.c b/libpldm/bios.c
index 1a705ff..c09696e 100644
--- a/libpldm/bios.c
+++ b/libpldm/bios.c
@@ -67,17 +67,18 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != PLDM_GET_DATE_TIME_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
struct pldm_get_date_time_resp *response =
(struct pldm_get_date_time_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- }
*seconds = response->seconds;
*minutes = response->minutes;
*hours = response->hours;
@@ -187,14 +188,15 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != sizeof(struct pldm_only_cc_resp)) {
return PLDM_ERROR_INVALID_LENGTH;
}
- const struct pldm_only_cc_resp *response =
- (struct pldm_only_cc_resp *)msg->payload;
- *completion_code = response->completion_code;
-
return PLDM_SUCCESS;
}
@@ -415,6 +417,12 @@
next_transfer_handle == NULL) {
return PLDM_ERROR_INVALID_DATA;
}
+
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != PLDM_SET_BIOS_ATTR_CURR_VAL_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
@@ -422,10 +430,6 @@
struct pldm_set_bios_attribute_current_value_resp *response =
(struct pldm_set_bios_attribute_current_value_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- }
*next_transfer_handle = le32toh(response->next_transfer_handle);
return PLDM_SUCCESS;
diff --git a/libpldm/bios.h b/libpldm/bios.h
index 8306576..065e53e 100644
--- a/libpldm/bios.h
+++ b/libpldm/bios.h
@@ -192,6 +192,12 @@
/** @brief Decode a GetDateTime response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
@@ -231,11 +237,17 @@
/** @brief Decode a SetBiosAttributeCurrentValue response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
* @param[out] next_transfer_handle - Pointer to a handle that identify the
- * next portion of the transfer
+ * next portion of the transfer
* @return pldm_completion_codes
*/
int decode_set_bios_attribute_current_value_resp(
@@ -453,6 +465,12 @@
/** @brief Decode a SetDateTime response message
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
diff --git a/libpldm/fru.c b/libpldm/fru.c
index b5801d7..f28231b 100644
--- a/libpldm/fru.c
+++ b/libpldm/fru.c
@@ -37,16 +37,17 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length != PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
struct pldm_get_fru_record_table_metadata_resp *response =
(struct pldm_get_fru_record_table_metadata_resp *)msg->payload;
- *completion_code = response->completion_code;
- if (PLDM_SUCCESS != *completion_code) {
- return PLDM_SUCCESS;
- };
*fru_data_major_version = response->fru_data_major_version;
*fru_data_minor_version = response->fru_data_minor_version;
diff --git a/libpldm/fru.h b/libpldm/fru.h
index 2b5dd9f..6a14956 100644
--- a/libpldm/fru.h
+++ b/libpldm/fru.h
@@ -138,6 +138,12 @@
/** @brief Decode GetFruRecordTable response data
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Response message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - Pointer to response msg's PLDM completion code
diff --git a/libpldm/platform.c b/libpldm/platform.c
index 8b9506f..1eb4656 100644
--- a/libpldm/platform.c
+++ b/libpldm/platform.c
@@ -63,12 +63,15 @@
return PLDM_ERROR_INVALID_DATA;
}
+ *completion_code = msg->payload[0];
+ if (PLDM_SUCCESS != *completion_code) {
+ return PLDM_SUCCESS;
+ }
+
if (payload_length > PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES) {
return PLDM_ERROR_INVALID_LENGTH;
}
- *completion_code = msg->payload[0];
-
return PLDM_SUCCESS;
}
@@ -220,7 +223,7 @@
*completion_code = msg->payload[0];
if (PLDM_SUCCESS != *completion_code) {
- return *completion_code;
+ return PLDM_SUCCESS;
}
if (payload_length < PLDM_GET_PDR_MIN_RESP_BYTES) {
diff --git a/libpldm/platform.h b/libpldm/platform.h
index 0935e04..5341f6f 100644
--- a/libpldm/platform.h
+++ b/libpldm/platform.h
@@ -314,6 +314,12 @@
/** @brief Decode GetPDR response data
*
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Request message
* @param[in] payload_length - Length of request message payload
* @param[out] completion_code - PLDM completion code
@@ -367,6 +373,13 @@
struct pldm_msg *msg);
/** @brief Decode SetStateEffecterStates response data
+ *
+ * Note:
+ * * If the return value is not PLDM_SUCCESS, it represents a
+ * transport layer error.
+ * * If the completion_code value is not PLDM_SUCCESS, it represents a
+ * protocol layer error and all the out-parameters are invalid.
+ *
* @param[in] msg - Request message
* @param[in] payload_length - Length of response message payload
* @param[out] completion_code - PLDM completion code
diff --git a/test/libpldm_base_test.cpp b/test/libpldm_base_test.cpp
index ffa76de..b8b25d3 100644
--- a/test/libpldm_base_test.cpp
+++ b/test/libpldm_base_test.cpp
@@ -21,33 +21,33 @@
// PLDM header information pointer is NULL
auto rc = pack_pldm_header(hdr_ptr, &msg);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
// PLDM message pointer is NULL
rc = pack_pldm_header(&hdr, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
// PLDM header information pointer and PLDM message pointer is NULL
rc = pack_pldm_header(hdr_ptr, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
// RESERVED message type
hdr.msg_type = PLDM_RESERVED;
rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
// Instance ID out of range
hdr.msg_type = PLDM_REQUEST;
hdr.instance = 32;
rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
// PLDM type out of range
hdr.msg_type = PLDM_REQUEST;
hdr.instance = 31;
hdr.pldm_type = 64;
rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_PLDM_TYPE);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_PLDM_TYPE);
}
TEST(PackPLDMMessage, RequestMessageGoodPath)
@@ -62,12 +62,12 @@
hdr.command = 0;
auto rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(msg.request, 1);
- ASSERT_EQ(msg.datagram, 0);
- ASSERT_EQ(msg.instance_id, 0);
- ASSERT_EQ(msg.type, 0);
- ASSERT_EQ(msg.command, 0);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(msg.request, 1);
+ EXPECT_EQ(msg.datagram, 0);
+ EXPECT_EQ(msg.instance_id, 0);
+ EXPECT_EQ(msg.type, 0);
+ EXPECT_EQ(msg.command, 0);
// Message type is REQUEST and upper range of the field values
hdr.instance = 31;
@@ -75,23 +75,23 @@
hdr.command = 255;
rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(msg.request, 1);
- ASSERT_EQ(msg.datagram, 0);
- ASSERT_EQ(msg.instance_id, 31);
- ASSERT_EQ(msg.type, 63);
- ASSERT_EQ(msg.command, 255);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(msg.request, 1);
+ EXPECT_EQ(msg.datagram, 0);
+ EXPECT_EQ(msg.instance_id, 31);
+ EXPECT_EQ(msg.type, 63);
+ EXPECT_EQ(msg.command, 255);
// Message type is PLDM_ASYNC_REQUEST_NOTIFY
hdr.msg_type = PLDM_ASYNC_REQUEST_NOTIFY;
rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(msg.request, 1);
- ASSERT_EQ(msg.datagram, 1);
- ASSERT_EQ(msg.instance_id, 31);
- ASSERT_EQ(msg.type, 63);
- ASSERT_EQ(msg.command, 255);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(msg.request, 1);
+ EXPECT_EQ(msg.datagram, 1);
+ EXPECT_EQ(msg.instance_id, 31);
+ EXPECT_EQ(msg.type, 63);
+ EXPECT_EQ(msg.command, 255);
}
TEST(PackPLDMMessage, ResponseMessageGoodPath)
@@ -106,12 +106,12 @@
hdr.command = 0;
auto rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(msg.request, 0);
- ASSERT_EQ(msg.datagram, 0);
- ASSERT_EQ(msg.instance_id, 0);
- ASSERT_EQ(msg.type, 0);
- ASSERT_EQ(msg.command, 0);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(msg.request, 0);
+ EXPECT_EQ(msg.datagram, 0);
+ EXPECT_EQ(msg.instance_id, 0);
+ EXPECT_EQ(msg.type, 0);
+ EXPECT_EQ(msg.command, 0);
// Message type is PLDM_RESPONSE and upper range of the field values
hdr.instance = 31;
@@ -119,12 +119,12 @@
hdr.command = 255;
rc = pack_pldm_header(&hdr, &msg);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(msg.request, 0);
- ASSERT_EQ(msg.datagram, 0);
- ASSERT_EQ(msg.instance_id, 31);
- ASSERT_EQ(msg.type, 63);
- ASSERT_EQ(msg.command, 255);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(msg.request, 0);
+ EXPECT_EQ(msg.datagram, 0);
+ EXPECT_EQ(msg.instance_id, 31);
+ EXPECT_EQ(msg.type, 63);
+ EXPECT_EQ(msg.command, 255);
}
TEST(UnpackPLDMMessage, BadPathTest)
@@ -133,7 +133,7 @@
// PLDM message pointer is NULL
auto rc = unpack_pldm_header(nullptr, &hdr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(UnpackPLDMMessage, RequestMessageGoodPath)
@@ -144,17 +144,17 @@
// Unpack PLDM request message and lower range of field values
msg.request = 1;
auto rc = unpack_pldm_header(&msg, &hdr);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(hdr.msg_type, PLDM_REQUEST);
- ASSERT_EQ(hdr.instance, 0);
- ASSERT_EQ(hdr.pldm_type, 0);
- ASSERT_EQ(hdr.command, 0);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(hdr.msg_type, PLDM_REQUEST);
+ EXPECT_EQ(hdr.instance, 0);
+ EXPECT_EQ(hdr.pldm_type, 0);
+ EXPECT_EQ(hdr.command, 0);
// Unpack PLDM async request message and lower range of field values
msg.datagram = 1;
rc = unpack_pldm_header(&msg, &hdr);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(hdr.msg_type, PLDM_ASYNC_REQUEST_NOTIFY);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(hdr.msg_type, PLDM_ASYNC_REQUEST_NOTIFY);
// Unpack PLDM request message and upper range of field values
msg.datagram = 0;
@@ -162,11 +162,11 @@
msg.type = 63;
msg.command = 255;
rc = unpack_pldm_header(&msg, &hdr);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(hdr.msg_type, PLDM_REQUEST);
- ASSERT_EQ(hdr.instance, 31);
- ASSERT_EQ(hdr.pldm_type, 63);
- ASSERT_EQ(hdr.command, 255);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(hdr.msg_type, PLDM_REQUEST);
+ EXPECT_EQ(hdr.instance, 31);
+ EXPECT_EQ(hdr.pldm_type, 63);
+ EXPECT_EQ(hdr.command, 255);
}
TEST(UnpackPLDMMessage, ResponseMessageGoodPath)
@@ -176,22 +176,22 @@
// Unpack PLDM response message and lower range of field values
auto rc = unpack_pldm_header(&msg, &hdr);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(hdr.msg_type, PLDM_RESPONSE);
- ASSERT_EQ(hdr.instance, 0);
- ASSERT_EQ(hdr.pldm_type, 0);
- ASSERT_EQ(hdr.command, 0);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(hdr.msg_type, PLDM_RESPONSE);
+ EXPECT_EQ(hdr.instance, 0);
+ EXPECT_EQ(hdr.pldm_type, 0);
+ EXPECT_EQ(hdr.command, 0);
// Unpack PLDM response message and upper range of field values
msg.instance_id = 31;
msg.type = 63;
msg.command = 255;
rc = unpack_pldm_header(&msg, &hdr);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(hdr.msg_type, PLDM_RESPONSE);
- ASSERT_EQ(hdr.instance, 31);
- ASSERT_EQ(hdr.pldm_type, 63);
- ASSERT_EQ(hdr.command, 255);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(hdr.msg_type, PLDM_RESPONSE);
+ EXPECT_EQ(hdr.instance, 31);
+ EXPECT_EQ(hdr.pldm_type, 63);
+ EXPECT_EQ(hdr.command, 255);
}
TEST(GetPLDMCommands, testEncodeRequest)
@@ -203,9 +203,9 @@
auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
auto rc = encode_get_commands_req(0, pldmType, version, request);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(0, memcmp(request->payload, &pldmType, sizeof(pldmType)));
- ASSERT_EQ(0, memcmp(request->payload + sizeof(pldmType), &version,
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(0, memcmp(request->payload, &pldmType, sizeof(pldmType)));
+ EXPECT_EQ(0, memcmp(request->payload + sizeof(pldmType), &version,
sizeof(version)));
}
@@ -225,9 +225,9 @@
auto rc = decode_get_commands_req(request, requestMsg.size() - hdrSize,
&pldmTypeOut, &versionOut);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(pldmTypeOut, pldmType);
- ASSERT_EQ(0, memcmp(&versionOut, &version, sizeof(version)));
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(pldmTypeOut, pldmType);
+ EXPECT_EQ(0, memcmp(&versionOut, &version, sizeof(version)));
}
TEST(GetPLDMCommands, testEncodeResponse)
@@ -243,13 +243,13 @@
auto rc =
encode_get_commands_resp(0, PLDM_SUCCESS, commands.data(), response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
uint8_t* payload_ptr = response->payload;
- ASSERT_EQ(completionCode, payload_ptr[0]);
- ASSERT_EQ(1, payload_ptr[sizeof(completionCode)]);
- ASSERT_EQ(2,
+ EXPECT_EQ(completionCode, payload_ptr[0]);
+ EXPECT_EQ(1, payload_ptr[sizeof(completionCode)]);
+ EXPECT_EQ(2,
payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte)]);
- ASSERT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte) +
+ EXPECT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(commands[0].byte) +
sizeof(commands[1].byte)]);
}
@@ -265,55 +265,98 @@
types[2].byte = 3;
auto rc = encode_get_types_resp(0, PLDM_SUCCESS, types.data(), response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
uint8_t* payload_ptr = response->payload;
- ASSERT_EQ(completionCode, payload_ptr[0]);
- ASSERT_EQ(1, payload_ptr[sizeof(completionCode)]);
- ASSERT_EQ(2, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte)]);
- ASSERT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte) +
+ EXPECT_EQ(completionCode, payload_ptr[0]);
+ EXPECT_EQ(1, payload_ptr[sizeof(completionCode)]);
+ EXPECT_EQ(2, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte)]);
+ EXPECT_EQ(3, payload_ptr[sizeof(completionCode) + sizeof(types[0].byte) +
sizeof(types[1].byte)]);
}
-TEST(GetPLDMTypes, testDecodeResponse)
+TEST(GetPLDMTypes, testGoodDecodeResponse)
{
std::array<uint8_t, hdrSize + PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
responseMsg[1 + hdrSize] = 1;
responseMsg[2 + hdrSize] = 2;
responseMsg[3 + hdrSize] = 3;
std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{};
+
uint8_t completion_code;
+ responseMsg[hdrSize] = PLDM_SUCCESS;
auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
auto rc = decode_get_types_resp(response, responseMsg.size() - hdrSize,
&completion_code, outTypes.data());
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completion_code, PLDM_SUCCESS);
- ASSERT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
- ASSERT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
- ASSERT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completion_code, PLDM_SUCCESS);
+ EXPECT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
+ EXPECT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
+ EXPECT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
}
-TEST(GetPLDMCommands, testDecodeResponse)
+TEST(GetPLDMTypes, testBadDecodeResponse)
+{
+ std::array<uint8_t, hdrSize + PLDM_GET_TYPES_RESP_BYTES> responseMsg{};
+ responseMsg[1 + hdrSize] = 1;
+ responseMsg[2 + hdrSize] = 2;
+ responseMsg[3 + hdrSize] = 3;
+ std::array<bitfield8_t, PLDM_MAX_TYPES / 8> outTypes{};
+
+ uint8_t retcompletion_code = 0;
+ responseMsg[hdrSize] = PLDM_SUCCESS;
+
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc = decode_get_types_resp(response, responseMsg.size() - hdrSize - 1,
+ &retcompletion_code, outTypes.data());
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+}
+
+TEST(GetPLDMCommands, testGoodDecodeResponse)
{
std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
responseMsg[1 + hdrSize] = 1;
responseMsg[2 + hdrSize] = 2;
responseMsg[3 + hdrSize] = 3;
std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{};
+
uint8_t completion_code;
+ responseMsg[hdrSize] = PLDM_SUCCESS;
auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
auto rc = decode_get_commands_resp(response, responseMsg.size() - hdrSize,
&completion_code, outTypes.data());
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completion_code, PLDM_SUCCESS);
- ASSERT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
- ASSERT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
- ASSERT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completion_code, PLDM_SUCCESS);
+ EXPECT_EQ(responseMsg[1 + hdrSize], outTypes[0].byte);
+ EXPECT_EQ(responseMsg[2 + hdrSize], outTypes[1].byte);
+ EXPECT_EQ(responseMsg[3 + hdrSize], outTypes[2].byte);
+}
+
+TEST(GetPLDMCommands, testBadDecodeResponse)
+{
+ std::array<uint8_t, hdrSize + PLDM_GET_COMMANDS_RESP_BYTES> responseMsg{};
+ responseMsg[1 + hdrSize] = 1;
+ responseMsg[2 + hdrSize] = 2;
+ responseMsg[3 + hdrSize] = 3;
+ std::array<bitfield8_t, PLDM_MAX_CMDS_PER_TYPE / 8> outTypes{};
+
+ uint8_t retcompletion_code = 0;
+ responseMsg[hdrSize] = PLDM_SUCCESS;
+
+ auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
+
+ auto rc =
+ decode_get_commands_resp(response, responseMsg.size() - hdrSize - 1,
+ &retcompletion_code, outTypes.data());
+
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}
TEST(GetPLDMVersion, testGoodEncodeRequest)
@@ -327,12 +370,12 @@
auto rc =
encode_get_version_req(0, transferHandle, opFlag, pldmType, request);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(
0, memcmp(request->payload, &transferHandle, sizeof(transferHandle)));
- ASSERT_EQ(0, memcmp(request->payload + sizeof(transferHandle), &opFlag,
+ EXPECT_EQ(0, memcmp(request->payload + sizeof(transferHandle), &opFlag,
sizeof(opFlag)));
- ASSERT_EQ(0,
+ EXPECT_EQ(0,
memcmp(request->payload + sizeof(transferHandle) + sizeof(opFlag),
&pldmType, sizeof(pldmType)));
}
@@ -346,7 +389,7 @@
auto rc =
encode_get_version_req(0, transferHandle, opFlag, pldmType, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(GetPLDMVersion, testEncodeResponse)
@@ -362,14 +405,14 @@
auto rc = encode_get_version_resp(0, PLDM_SUCCESS, 0, PLDM_START_AND_END,
&version, sizeof(ver32_t), response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completionCode, response->payload[0]);
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completionCode, response->payload[0]);
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
&transferHandle, sizeof(transferHandle)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(transferHandle),
&flag, sizeof(flag)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(transferHandle) + sizeof(flag),
&version, sizeof(version)));
}
@@ -396,10 +439,10 @@
auto rc = decode_get_version_req(request, requestMsg.size() - hdrSize,
&retTransferHandle, &retFlag, &retType);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(transferHandle, retTransferHandle);
- ASSERT_EQ(flag, retFlag);
- ASSERT_EQ(pldmType, retType);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(transferHandle, retTransferHandle);
+ EXPECT_EQ(flag, retFlag);
+ EXPECT_EQ(pldmType, retType);
}
TEST(GetPLDMVersion, testDecodeResponse)
@@ -429,14 +472,14 @@
auto rc = decode_get_version_resp(response, responseMsg.size() - hdrSize,
&completion_code, &retTransferHandle,
&retFlag, &versionOut);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(transferHandle, retTransferHandle);
- ASSERT_EQ(flag, retFlag);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(transferHandle, retTransferHandle);
+ EXPECT_EQ(flag, retFlag);
- ASSERT_EQ(versionOut.major, version.major);
- ASSERT_EQ(versionOut.minor, version.minor);
- ASSERT_EQ(versionOut.update, version.update);
- ASSERT_EQ(versionOut.alpha, version.alpha);
+ EXPECT_EQ(versionOut.major, version.major);
+ EXPECT_EQ(versionOut.minor, version.minor);
+ EXPECT_EQ(versionOut.update, version.update);
+ EXPECT_EQ(versionOut.alpha, version.alpha);
}
TEST(GetTID, testEncodeRequest)
@@ -456,10 +499,10 @@
uint8_t tid = 1;
auto rc = encode_get_tid_resp(0, PLDM_SUCCESS, tid, response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
uint8_t* payload = response->payload;
- ASSERT_EQ(completionCode, payload[0]);
- ASSERT_EQ(1, payload[sizeof(completionCode)]);
+ EXPECT_EQ(completionCode, payload[0]);
+ EXPECT_EQ(1, payload[sizeof(completionCode)]);
}
TEST(GetTID, testDecodeResponse)
@@ -469,15 +512,16 @@
uint8_t tid;
uint8_t completion_code;
+ responseMsg[hdrSize] = PLDM_SUCCESS;
auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
auto rc = decode_get_tid_resp(response, responseMsg.size() - hdrSize,
&completion_code, &tid);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completion_code, PLDM_SUCCESS);
- ASSERT_EQ(tid, 1);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completion_code, PLDM_SUCCESS);
+ EXPECT_EQ(tid, 1);
}
TEST(CcOnlyResponse, testEncode)
diff --git a/test/libpldm_bios_test.cpp b/test/libpldm_bios_test.cpp
index 89d3747..012206a 100644
--- a/test/libpldm_bios_test.cpp
+++ b/test/libpldm_bios_test.cpp
@@ -15,7 +15,7 @@
pldm_msg request{};
auto rc = encode_get_date_time_req(0, &request);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
}
TEST(GetDateTime, testEncodeResponse)
@@ -36,25 +36,25 @@
auto rc = encode_get_date_time_resp(0, PLDM_SUCCESS, seconds, minutes,
hours, day, month, year, response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completionCode, response->payload[0]);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completionCode, response->payload[0]);
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
&seconds, sizeof(seconds)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(seconds),
&minutes, sizeof(minutes)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(seconds) + sizeof(minutes),
&hours, sizeof(hours)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(seconds) + sizeof(minutes) + sizeof(hours),
&day, sizeof(day)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
sizeof(day),
&month, sizeof(month)));
- ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
+ EXPECT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
sizeof(seconds) + sizeof(minutes) + sizeof(hours) +
sizeof(day) + sizeof(month),
&year, sizeof(year)));
@@ -105,13 +105,13 @@
response, responseMsg.size() - hdrSize, &completionCode, &retSeconds,
&retMinutes, &retHours, &retDay, &retMonth, &retYear);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(seconds, retSeconds);
- ASSERT_EQ(minutes, retMinutes);
- ASSERT_EQ(hours, retHours);
- ASSERT_EQ(day, retDay);
- ASSERT_EQ(month, retMonth);
- ASSERT_EQ(year, retYear);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(seconds, retSeconds);
+ EXPECT_EQ(minutes, retMinutes);
+ EXPECT_EQ(hours, retHours);
+ EXPECT_EQ(day, retDay);
+ EXPECT_EQ(month, retMonth);
+ EXPECT_EQ(year, retYear);
}
TEST(SetDateTime, testGoodEncodeResponse)
@@ -343,15 +343,15 @@
0, PLDM_SUCCESS, nextTransferHandle, transferFlag, tableData.data(),
sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES + 4,
response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
struct pldm_get_bios_table_resp* resp =
reinterpret_cast<struct pldm_get_bios_table_resp*>(response->payload);
- ASSERT_EQ(completionCode, resp->completion_code);
- ASSERT_EQ(nextTransferHandle, resp->next_transfer_handle);
- ASSERT_EQ(transferFlag, resp->transfer_flag);
- ASSERT_EQ(0, memcmp(tableData.data(), resp->table_data, tableData.size()));
+ EXPECT_EQ(completionCode, resp->completion_code);
+ EXPECT_EQ(nextTransferHandle, resp->next_transfer_handle);
+ EXPECT_EQ(transferFlag, resp->transfer_flag);
+ EXPECT_EQ(0, memcmp(tableData.data(), resp->table_data, tableData.size()));
}
TEST(GetBIOSTable, testBadEncodeResponse)
@@ -363,7 +363,7 @@
auto rc = encode_get_bios_table_resp(
0, PLDM_SUCCESS, nextTransferHandle, transferFlag, tableData.data(),
sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES + 4, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(GetBIOSTable, testGoodEncodeRequest)
@@ -378,13 +378,13 @@
auto rc = encode_get_bios_table_req(0, transferHandle, transferOpFlag,
tableType, request);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
struct pldm_get_bios_table_req* req =
reinterpret_cast<struct pldm_get_bios_table_req*>(request->payload);
- ASSERT_EQ(transferHandle, le32toh(req->transfer_handle));
- ASSERT_EQ(transferOpFlag, req->transfer_op_flag);
- ASSERT_EQ(tableType, req->table_type);
+ EXPECT_EQ(transferHandle, le32toh(req->transfer_handle));
+ EXPECT_EQ(transferOpFlag, req->transfer_op_flag);
+ EXPECT_EQ(tableType, req->table_type);
}
TEST(GetBIOSTable, testBadEncodeRequest)
@@ -396,7 +396,7 @@
auto rc = encode_get_bios_table_req(0, transferHandle, transferOpFlag,
tableType, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(GetBIOSTable, testGoodDecodeRequest)
@@ -422,10 +422,10 @@
&retTransferHandle, &retTransferOpFlag,
&retTableType);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(transferHandle, retTransferHandle);
- ASSERT_EQ(transferOpFlag, retTransferOpFlag);
- ASSERT_EQ(tableType, retTableType);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(transferHandle, retTransferHandle);
+ EXPECT_EQ(transferOpFlag, retTransferOpFlag);
+ EXPECT_EQ(tableType, retTableType);
}
TEST(GetBIOSTable, testBadDecodeRequest)
{
@@ -450,10 +450,10 @@
&retTransferHandle, &retTransferOpFlag,
&retTableType);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(transferHandle, retTransferHandle);
- ASSERT_EQ(transferOpFlag, retTransferOpFlag);
- ASSERT_EQ(tableType, retTableType);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(transferHandle, retTransferHandle);
+ EXPECT_EQ(transferOpFlag, retTransferOpFlag);
+ EXPECT_EQ(tableType, retTableType);
}
/*
TEST(GetBIOSTable, testBadDecodeRequest)
@@ -479,7 +479,7 @@
&retTransferHandle, &retTransferOpFlag,
&retTableType);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}*/
TEST(GetBIOSAttributeCurrentValueByHandle, testGoodDecodeRequest)
@@ -508,10 +508,10 @@
req, requestMsg.size() - hdrSize, &retTransferHandle,
&retTransferOpFlag, &retattributehandle);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(transferHandle, retTransferHandle);
- ASSERT_EQ(transferOpFlag, retTransferOpFlag);
- ASSERT_EQ(attributehandle, retattributehandle);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(transferHandle, retTransferHandle);
+ EXPECT_EQ(transferOpFlag, retTransferOpFlag);
+ EXPECT_EQ(attributehandle, retattributehandle);
}
TEST(GetBIOSAttributeCurrentValueByHandle, testBadDecodeRequest)
@@ -540,7 +540,7 @@
auto rc = decode_get_bios_attribute_current_value_by_handle_req(
NULL, requestMsg.size() - hdrSize, &retTransferHandle,
&retTransferOpFlag, &retattribute_handle);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
transferHandle = 31;
request->transfer_handle = transferHandle;
@@ -548,7 +548,7 @@
rc = decode_get_bios_attribute_current_value_by_handle_req(
req, 0, &retTransferHandle, &retTransferOpFlag, &retattribute_handle);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}
TEST(GetBIOSAttributeCurrentValueByHandle, testGoodEncodeResponse)
@@ -569,17 +569,17 @@
instanceId, completionCode, nextTransferHandle, transferFlag,
&attributeData, sizeof(attributeData), response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
struct pldm_get_bios_attribute_current_value_by_handle_resp* resp =
reinterpret_cast<
struct pldm_get_bios_attribute_current_value_by_handle_resp*>(
response->payload);
- ASSERT_EQ(completionCode, resp->completion_code);
- ASSERT_EQ(nextTransferHandle, resp->next_transfer_handle);
- ASSERT_EQ(transferFlag, resp->transfer_flag);
- ASSERT_EQ(
+ EXPECT_EQ(completionCode, resp->completion_code);
+ EXPECT_EQ(nextTransferHandle, resp->next_transfer_handle);
+ EXPECT_EQ(transferFlag, resp->transfer_flag);
+ EXPECT_EQ(
0, memcmp(&attributeData, resp->attribute_data, sizeof(attributeData)));
}
@@ -592,7 +592,7 @@
auto rc = encode_get_bios_current_value_by_handle_resp(
0, PLDM_SUCCESS, nextTransferHandle, transferFlag, &attributeData,
sizeof(attributeData), nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
std::array<uint8_t,
hdrSize +
@@ -602,7 +602,7 @@
rc = encode_get_bios_current_value_by_handle_resp(
0, PLDM_SUCCESS, nextTransferHandle, transferFlag, nullptr,
sizeof(attributeData), response);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(SetBiosAttributeCurrentValue, testGoodEncodeRequest)
@@ -620,14 +620,14 @@
reinterpret_cast<uint8_t*>(&attributeData), sizeof(attributeData),
request, requestMsg.size() - hdrSize);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
struct pldm_set_bios_attribute_current_value_req* req =
reinterpret_cast<struct pldm_set_bios_attribute_current_value_req*>(
request->payload);
- ASSERT_EQ(htole32(transferHandle), req->transfer_handle);
- ASSERT_EQ(transferFlag, req->transfer_flag);
- ASSERT_EQ(
+ EXPECT_EQ(htole32(transferHandle), req->transfer_handle);
+ EXPECT_EQ(transferFlag, req->transfer_flag);
+ EXPECT_EQ(
0, memcmp(&attributeData, req->attribute_data, sizeof(attributeData)));
}
@@ -643,13 +643,13 @@
auto rc = encode_set_bios_attribute_current_value_req(
instanceId, transferHandle, transferFlag, nullptr, 0, nullptr, 0);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
rc = encode_set_bios_attribute_current_value_req(
instanceId, transferHandle, transferFlag,
reinterpret_cast<uint8_t*>(&attributeData), sizeof(attributeData),
request, requestMsg.size() - hdrSize);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}
TEST(SetBiosAttributeCurrentValue, testGoodDecodeRequest)
@@ -678,11 +678,11 @@
&retTransferFlag, reinterpret_cast<uint8_t*>(&retAttributeData),
&retAttributeDataLength);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(retTransferHandle, transferHandle);
- ASSERT_EQ(retTransferFlag, transferFlag);
- ASSERT_EQ(retAttributeDataLength, sizeof(attributeData));
- ASSERT_EQ(0,
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retTransferHandle, transferHandle);
+ EXPECT_EQ(retTransferFlag, transferFlag);
+ EXPECT_EQ(retAttributeDataLength, sizeof(attributeData));
+ EXPECT_EQ(0,
memcmp(&retAttributeData, &attributeData, sizeof(attributeData)));
}
@@ -699,11 +699,11 @@
auto rc = decode_set_bios_attribute_current_value_req(
nullptr, 0, &transferHandle, &transferFlag,
reinterpret_cast<uint8_t*>(&attributeData), &attributeDataLength);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
rc = decode_set_bios_attribute_current_value_req(
request, requestMsg.size() - hdrSize, &transferHandle, &transferFlag,
reinterpret_cast<uint8_t*>(&attributeData), &attributeDataLength);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}
TEST(SetBiosAttributeCurrentValue, testGoodEncodeResponse)
@@ -718,13 +718,13 @@
reinterpret_cast<struct pldm_msg*>(responseMsg.data());
auto rc = encode_set_bios_attribute_current_value_resp(
instanceId, completionCode, nextTransferHandle, response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
struct pldm_set_bios_attribute_current_value_resp* resp =
reinterpret_cast<struct pldm_set_bios_attribute_current_value_resp*>(
response->payload);
- ASSERT_EQ(completionCode, resp->completion_code);
- ASSERT_EQ(htole32(nextTransferHandle), resp->next_transfer_handle);
+ EXPECT_EQ(completionCode, resp->completion_code);
+ EXPECT_EQ(htole32(nextTransferHandle), resp->next_transfer_handle);
}
TEST(SetBiosAttributeCurrentValue, testBadEncodeResponse)
@@ -735,7 +735,7 @@
auto rc = encode_set_bios_attribute_current_value_resp(
instanceId, completionCode, nextTransferHandle, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(SetBiosAttributeCurrentValue, testGoodDecodeResponse)
{
@@ -758,9 +758,9 @@
response, responseMsg.size() - hdrSize, &retCompletionCode,
&retNextTransferHandle);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completionCode, retCompletionCode);
- ASSERT_EQ(nextTransferHandle, retNextTransferHandle);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completionCode, retCompletionCode);
+ EXPECT_EQ(nextTransferHandle, retNextTransferHandle);
}
TEST(SetBiosAttributeCurrentValue, testBadDecodeResponse)
@@ -768,19 +768,26 @@
uint32_t nextTransferHandle = 32;
uint8_t completionCode = PLDM_SUCCESS;
- std::array<uint8_t, hdrSize + PLDM_SET_BIOS_ATTR_CURR_VAL_RESP_BYTES - 1>
+ std::array<uint8_t, hdrSize + PLDM_SET_BIOS_ATTR_CURR_VAL_RESP_BYTES>
responseMsg{};
struct pldm_msg* response =
reinterpret_cast<struct pldm_msg*>(responseMsg.data());
+ struct pldm_set_bios_attribute_current_value_resp* resp =
+ reinterpret_cast<struct pldm_set_bios_attribute_current_value_resp*>(
+ response->payload);
+
+ resp->completion_code = completionCode;
+ resp->next_transfer_handle = htole32(nextTransferHandle);
+
auto rc = decode_set_bios_attribute_current_value_resp(
nullptr, 0, &completionCode, &nextTransferHandle);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
rc = decode_set_bios_attribute_current_value_resp(
- response, responseMsg.size() - hdrSize, &completionCode,
+ response, responseMsg.size() - hdrSize - 1, &completionCode,
&nextTransferHandle);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
}
TEST(GetBIOSTable, testDecodeResponse)
diff --git a/test/libpldm_platform_test.cpp b/test/libpldm_platform_test.cpp
index 244131d..11252d6 100644
--- a/test/libpldm_platform_test.cpp
+++ b/test/libpldm_platform_test.cpp
@@ -19,8 +19,8 @@
auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completionCode, response->payload[0]);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(completionCode, response->payload[0]);
}
TEST(SetStateEffecterStates, testEncodeRequest)
@@ -39,18 +39,18 @@
auto rc = encode_set_state_effecter_states_req(
0, effecterId, compEffecterCnt, stateField.data(), request);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(effecterId, request->payload[0]);
- ASSERT_EQ(compEffecterCnt, request->payload[sizeof(effecterId)]);
- ASSERT_EQ(stateField[0].set_request,
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(effecterId, request->payload[0]);
+ EXPECT_EQ(compEffecterCnt, request->payload[sizeof(effecterId)]);
+ EXPECT_EQ(stateField[0].set_request,
request->payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
- ASSERT_EQ(stateField[0].effecter_state,
+ EXPECT_EQ(stateField[0].effecter_state,
request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
sizeof(stateField[0].set_request)]);
- ASSERT_EQ(stateField[1].set_request,
+ EXPECT_EQ(stateField[1].set_request,
request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
sizeof(stateField[0])]);
- ASSERT_EQ(stateField[1].effecter_state,
+ EXPECT_EQ(stateField[1].effecter_state,
request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
sizeof(stateField[0]) +
sizeof(stateField[1].set_request)]);
@@ -61,20 +61,17 @@
std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
responseMsg{};
- uint8_t completion_code = 0xA0;
-
uint8_t retcompletion_code = 0;
- memcpy(responseMsg.data() + hdrSize, &completion_code,
- sizeof(completion_code));
+ responseMsg[hdrSize] = PLDM_SUCCESS;
auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
auto rc = decode_set_state_effecter_states_resp(
response, responseMsg.size() - hdrSize, &retcompletion_code);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(completion_code, retcompletion_code);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(PLDM_SUCCESS, retcompletion_code);
}
TEST(SetStateEffecterStates, testGoodDecodeRequest)
@@ -107,13 +104,13 @@
request, requestMsg.size() - hdrSize, &retEffecterId,
&retCompEffecterCnt, retStateField.data());
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(effecterId, retEffecterId);
- ASSERT_EQ(retCompEffecterCnt, compEffecterCnt);
- ASSERT_EQ(retStateField[0].set_request, stateField[0].set_request);
- ASSERT_EQ(retStateField[0].effecter_state, stateField[0].effecter_state);
- ASSERT_EQ(retStateField[1].set_request, stateField[1].set_request);
- ASSERT_EQ(retStateField[1].effecter_state, stateField[1].effecter_state);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(effecterId, retEffecterId);
+ EXPECT_EQ(retCompEffecterCnt, compEffecterCnt);
+ EXPECT_EQ(retStateField[0].set_request, stateField[0].set_request);
+ EXPECT_EQ(retStateField[0].effecter_state, stateField[0].effecter_state);
+ EXPECT_EQ(retStateField[1].set_request, stateField[1].set_request);
+ EXPECT_EQ(retStateField[1].effecter_state, stateField[1].effecter_state);
}
TEST(SetStateEffecterStates, testBadDecodeRequest)
@@ -123,7 +120,7 @@
auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
NULL, NULL);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(SetStateEffecterStates, testBadDecodeResponse)
@@ -136,7 +133,7 @@
auto rc = decode_set_state_effecter_states_resp(response,
responseMsg.size(), NULL);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(GetPDR, testGoodEncodeResponse)
@@ -158,18 +155,18 @@
nextDataTransferHndl, transferFlag, respCnt,
recordData.data(), transferCRC, response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
struct pldm_get_pdr_resp* resp =
reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
- ASSERT_EQ(completionCode, resp->completion_code);
- ASSERT_EQ(nextRecordHndl, resp->next_record_handle);
- ASSERT_EQ(nextDataTransferHndl, resp->next_data_transfer_handle);
- ASSERT_EQ(transferFlag, resp->transfer_flag);
- ASSERT_EQ(respCnt, resp->response_count);
- ASSERT_EQ(0,
+ EXPECT_EQ(completionCode, resp->completion_code);
+ EXPECT_EQ(nextRecordHndl, resp->next_record_handle);
+ EXPECT_EQ(nextDataTransferHndl, resp->next_data_transfer_handle);
+ EXPECT_EQ(transferFlag, resp->transfer_flag);
+ EXPECT_EQ(respCnt, resp->response_count);
+ EXPECT_EQ(0,
memcmp(recordData.data(), resp->record_data, recordData.size()));
- ASSERT_EQ(*(response->payload + sizeof(pldm_get_pdr_resp) - 1 +
+ EXPECT_EQ(*(response->payload + sizeof(pldm_get_pdr_resp) - 1 +
recordData.size()),
transferCRC);
@@ -178,7 +175,7 @@
rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
nextDataTransferHndl, transferFlag, respCnt,
recordData.data(), transferCRC, response);
- ASSERT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
}
TEST(GetPDR, testBadEncodeResponse)
@@ -194,7 +191,7 @@
nextDataTransferHndl, transferFlag, respCnt,
recordData.data(), transferCRC, nullptr);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(GetPDR, testGoodDecodeRequest)
@@ -227,12 +224,12 @@
req, requestMsg.size() - hdrSize, &retRecordHndl, &retDataTransferHndl,
&retTransferOpFlag, &retRequestCnt, &retRecordChangeNum);
- ASSERT_EQ(rc, PLDM_SUCCESS);
- ASSERT_EQ(retRecordHndl, recordHndl);
- ASSERT_EQ(retDataTransferHndl, dataTransferHndl);
- ASSERT_EQ(retTransferOpFlag, transferOpFlag);
- ASSERT_EQ(retRequestCnt, requestCnt);
- ASSERT_EQ(retRecordChangeNum, recordChangeNum);
+ EXPECT_EQ(rc, PLDM_SUCCESS);
+ EXPECT_EQ(retRecordHndl, recordHndl);
+ EXPECT_EQ(retDataTransferHndl, dataTransferHndl);
+ EXPECT_EQ(retTransferOpFlag, transferOpFlag);
+ EXPECT_EQ(retRequestCnt, requestCnt);
+ EXPECT_EQ(retRecordChangeNum, recordChangeNum);
}
TEST(GetPDR, testBadDecodeRequest)
@@ -243,7 +240,7 @@
auto rc = decode_get_pdr_req(req, requestMsg.size(), NULL, NULL, NULL, NULL,
NULL);
- ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
+ EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
}
TEST(GetPDR, testGoodEncodeRequest)
@@ -323,8 +320,7 @@
resp->transfer_flag = transferFlag;
resp->response_count = htole16(respCnt);
memcpy(resp->record_data, recordData, respCnt);
- memcpy(response->payload + PLDM_GET_PDR_MIN_RESP_BYTES + respCnt,
- &transferCRC, 1);
+ response->payload[PLDM_GET_PDR_MIN_RESP_BYTES + respCnt] = transferCRC;
auto rc = decode_get_pdr_resp(
response, responseMsg.size() - hdrSize, &retCompletionCode,
@@ -355,7 +351,7 @@
responseMsg{};
uint8_t retCompletionCode = 0;
- uint8_t retRecordData[32];
+ uint8_t retRecordData[32] = {0};
uint32_t retNextRecordHndl = 0;
uint32_t retNextDataTransferHndl = 0;
uint8_t retTransferFlag = 0;
@@ -371,8 +367,7 @@
resp->transfer_flag = transferFlag;
resp->response_count = htole16(respCnt);
memcpy(resp->record_data, recordData, respCnt);
- memcpy(response->payload + PLDM_GET_PDR_MIN_RESP_BYTES + respCnt,
- &transferCRC, 1);
+ response->payload[PLDM_GET_PDR_MIN_RESP_BYTES + respCnt] = transferCRC;
auto rc = decode_get_pdr_resp(response, responseMsg.size() - hdrSize, NULL,
NULL, NULL, NULL, NULL, NULL, 0, NULL);