blob: 1261d0b3e601c81cc702fb960240da4824285cf3 [file] [log] [blame]
Sampa Misra0db1dfa2019-03-19 00:15:31 -05001#include <string.h>
2
3#include <array>
4
5#include "libpldm/base.h"
6#include "libpldm/platform.h"
7
8#include <gtest/gtest.h>
9
Zahed Hossain223a73d2019-07-04 12:46:18 -050010constexpr auto hdrSize = sizeof(pldm_msg_hdr);
11
Sampa Misra0db1dfa2019-03-19 00:15:31 -050012TEST(SetStateEffecterStates, testEncodeResponse)
13{
vkaverapa6575b82019-04-03 05:33:52 -050014 std::array<uint8_t,
15 sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
16 responseMsg{};
17 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
Sampa Misra0db1dfa2019-03-19 00:15:31 -050018 uint8_t completionCode = 0;
19
vkaverapa6575b82019-04-03 05:33:52 -050020 auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, response);
Sampa Misra0db1dfa2019-03-19 00:15:31 -050021
George Liu684a7162019-12-06 15:10:52 +080022 EXPECT_EQ(rc, PLDM_SUCCESS);
23 EXPECT_EQ(completionCode, response->payload[0]);
Sampa Misra0db1dfa2019-03-19 00:15:31 -050024}
25
vkaverap98a2c192019-04-03 05:33:52 -050026TEST(SetStateEffecterStates, testEncodeRequest)
27{
vkaverapa6575b82019-04-03 05:33:52 -050028 std::array<uint8_t,
29 sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
30 requestMsg{};
31 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
32
vkaverap98a2c192019-04-03 05:33:52 -050033 uint16_t effecterId = 0x0A;
34 uint8_t compEffecterCnt = 0x2;
35 std::array<set_effecter_state_field, 8> stateField{};
36 stateField[0] = {PLDM_REQUEST_SET, 2};
37 stateField[1] = {PLDM_REQUEST_SET, 3};
38
vkaverap98a2c192019-04-03 05:33:52 -050039 auto rc = encode_set_state_effecter_states_req(
vkaverapa6575b82019-04-03 05:33:52 -050040 0, effecterId, compEffecterCnt, stateField.data(), request);
vkaverap98a2c192019-04-03 05:33:52 -050041
George Liu684a7162019-12-06 15:10:52 +080042 EXPECT_EQ(rc, PLDM_SUCCESS);
43 EXPECT_EQ(effecterId, request->payload[0]);
44 EXPECT_EQ(compEffecterCnt, request->payload[sizeof(effecterId)]);
45 EXPECT_EQ(stateField[0].set_request,
vkaverapa6575b82019-04-03 05:33:52 -050046 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
George Liu684a7162019-12-06 15:10:52 +080047 EXPECT_EQ(stateField[0].effecter_state,
vkaverapa6575b82019-04-03 05:33:52 -050048 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
49 sizeof(stateField[0].set_request)]);
George Liu684a7162019-12-06 15:10:52 +080050 EXPECT_EQ(stateField[1].set_request,
vkaverapa6575b82019-04-03 05:33:52 -050051 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
52 sizeof(stateField[0])]);
George Liu684a7162019-12-06 15:10:52 +080053 EXPECT_EQ(stateField[1].effecter_state,
vkaverapa6575b82019-04-03 05:33:52 -050054 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
55 sizeof(stateField[0]) +
56 sizeof(stateField[1].set_request)]);
vkaverap98a2c192019-04-03 05:33:52 -050057}
58
59TEST(SetStateEffecterStates, testGoodDecodeResponse)
60{
Zahed Hossain223a73d2019-07-04 12:46:18 -050061 std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
vkaverap98a2c192019-04-03 05:33:52 -050062 responseMsg{};
63
vkaverap98a2c192019-04-03 05:33:52 -050064 uint8_t retcompletion_code = 0;
65
George Liu684a7162019-12-06 15:10:52 +080066 responseMsg[hdrSize] = PLDM_SUCCESS;
Zahed Hossain223a73d2019-07-04 12:46:18 -050067
68 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
vkaverap98a2c192019-04-03 05:33:52 -050069
vkaverapa6575b82019-04-03 05:33:52 -050070 auto rc = decode_set_state_effecter_states_resp(
Zahed Hossain223a73d2019-07-04 12:46:18 -050071 response, responseMsg.size() - hdrSize, &retcompletion_code);
vkaverap98a2c192019-04-03 05:33:52 -050072
George Liu684a7162019-12-06 15:10:52 +080073 EXPECT_EQ(rc, PLDM_SUCCESS);
74 EXPECT_EQ(PLDM_SUCCESS, retcompletion_code);
vkaverap98a2c192019-04-03 05:33:52 -050075}
76
Sampa Misra0db1dfa2019-03-19 00:15:31 -050077TEST(SetStateEffecterStates, testGoodDecodeRequest)
78{
Zahed Hossain223a73d2019-07-04 12:46:18 -050079 std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
80 requestMsg{};
Sampa Misra0db1dfa2019-03-19 00:15:31 -050081
Lei YU065cf762020-02-28 15:31:28 +080082 uint16_t effecterId = 0x32;
83 uint16_t effecterIdLE = htole16(effecterId);
Sampa Misra0db1dfa2019-03-19 00:15:31 -050084 uint8_t compEffecterCnt = 0x2;
85
86 std::array<set_effecter_state_field, 8> stateField{};
87 stateField[0] = {PLDM_REQUEST_SET, 3};
88 stateField[1] = {PLDM_REQUEST_SET, 4};
89
90 uint16_t retEffecterId = 0;
91 uint8_t retCompEffecterCnt = 0;
92
93 std::array<set_effecter_state_field, 8> retStateField{};
94
Lei YU065cf762020-02-28 15:31:28 +080095 memcpy(requestMsg.data() + hdrSize, &effecterIdLE, sizeof(effecterIdLE));
96 memcpy(requestMsg.data() + sizeof(effecterIdLE) + hdrSize, &compEffecterCnt,
Sampa Misra0db1dfa2019-03-19 00:15:31 -050097 sizeof(compEffecterCnt));
Lei YU065cf762020-02-28 15:31:28 +080098 memcpy(requestMsg.data() + sizeof(effecterIdLE) + sizeof(compEffecterCnt) +
Zahed Hossain223a73d2019-07-04 12:46:18 -050099 hdrSize,
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500100 &stateField, sizeof(stateField));
101
Zahed Hossain223a73d2019-07-04 12:46:18 -0500102 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
103
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500104 auto rc = decode_set_state_effecter_states_req(
Zahed Hossain223a73d2019-07-04 12:46:18 -0500105 request, requestMsg.size() - hdrSize, &retEffecterId,
vkaverapa6575b82019-04-03 05:33:52 -0500106 &retCompEffecterCnt, retStateField.data());
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500107
George Liu684a7162019-12-06 15:10:52 +0800108 EXPECT_EQ(rc, PLDM_SUCCESS);
109 EXPECT_EQ(effecterId, retEffecterId);
110 EXPECT_EQ(retCompEffecterCnt, compEffecterCnt);
111 EXPECT_EQ(retStateField[0].set_request, stateField[0].set_request);
112 EXPECT_EQ(retStateField[0].effecter_state, stateField[0].effecter_state);
113 EXPECT_EQ(retStateField[1].set_request, stateField[1].set_request);
114 EXPECT_EQ(retStateField[1].effecter_state, stateField[1].effecter_state);
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500115}
116
117TEST(SetStateEffecterStates, testBadDecodeRequest)
118{
Zahed Hossain223a73d2019-07-04 12:46:18 -0500119 const struct pldm_msg* msg = NULL;
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500120
vkaverapa6575b82019-04-03 05:33:52 -0500121 auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
122 NULL, NULL);
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500123
George Liu684a7162019-12-06 15:10:52 +0800124 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
Sampa Misra0db1dfa2019-03-19 00:15:31 -0500125}
vkaverap98a2c192019-04-03 05:33:52 -0500126
127TEST(SetStateEffecterStates, testBadDecodeResponse)
128{
129 std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
130 responseMsg{};
131
Zahed Hossain223a73d2019-07-04 12:46:18 -0500132 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
133
134 auto rc = decode_set_state_effecter_states_resp(response,
vkaverapa6575b82019-04-03 05:33:52 -0500135 responseMsg.size(), NULL);
vkaverap98a2c192019-04-03 05:33:52 -0500136
George Liu684a7162019-12-06 15:10:52 +0800137 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
vkaverap98a2c192019-04-03 05:33:52 -0500138}
Sampa Misra7fcfb662019-05-08 13:13:53 -0500139
140TEST(GetPDR, testGoodEncodeResponse)
141{
142 uint8_t completionCode = 0;
143 uint32_t nextRecordHndl = 0x12;
144 uint32_t nextDataTransferHndl = 0x13;
Deepak Kodihallie4b16ee2019-08-14 06:54:38 -0500145 uint8_t transferFlag = PLDM_END;
Sampa Misra7fcfb662019-05-08 13:13:53 -0500146 uint16_t respCnt = 0x5;
147 std::vector<uint8_t> recordData{1, 2, 3, 4, 5};
Deepak Kodihallie4b16ee2019-08-14 06:54:38 -0500148 uint8_t transferCRC = 6;
Sampa Misra7fcfb662019-05-08 13:13:53 -0500149
150 // + size of record data and transfer CRC
151 std::vector<uint8_t> responseMsg(hdrSize + PLDM_GET_PDR_MIN_RESP_BYTES +
152 recordData.size() + 1);
153 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
154
155 auto rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
156 nextDataTransferHndl, transferFlag, respCnt,
157 recordData.data(), transferCRC, response);
158
George Liu684a7162019-12-06 15:10:52 +0800159 EXPECT_EQ(rc, PLDM_SUCCESS);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500160 struct pldm_get_pdr_resp* resp =
161 reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
162
George Liu684a7162019-12-06 15:10:52 +0800163 EXPECT_EQ(completionCode, resp->completion_code);
Lei YU065cf762020-02-28 15:31:28 +0800164 EXPECT_EQ(nextRecordHndl, le32toh(resp->next_record_handle));
165 EXPECT_EQ(nextDataTransferHndl, le32toh(resp->next_data_transfer_handle));
George Liu684a7162019-12-06 15:10:52 +0800166 EXPECT_EQ(transferFlag, resp->transfer_flag);
Lei YU065cf762020-02-28 15:31:28 +0800167 EXPECT_EQ(respCnt, le16toh(resp->response_count));
George Liu684a7162019-12-06 15:10:52 +0800168 EXPECT_EQ(0,
Sampa Misra7fcfb662019-05-08 13:13:53 -0500169 memcmp(recordData.data(), resp->record_data, recordData.size()));
George Liu684a7162019-12-06 15:10:52 +0800170 EXPECT_EQ(*(response->payload + sizeof(pldm_get_pdr_resp) - 1 +
Deepak Kodihallie4b16ee2019-08-14 06:54:38 -0500171 recordData.size()),
172 transferCRC);
173
174 transferFlag = PLDM_START_AND_END; // No CRC in this case
175 responseMsg.resize(responseMsg.size() - sizeof(transferCRC));
176 rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
177 nextDataTransferHndl, transferFlag, respCnt,
178 recordData.data(), transferCRC, response);
George Liu684a7162019-12-06 15:10:52 +0800179 EXPECT_EQ(rc, PLDM_SUCCESS);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500180}
181
182TEST(GetPDR, testBadEncodeResponse)
183{
184 uint32_t nextRecordHndl = 0x12;
185 uint32_t nextDataTransferHndl = 0x13;
186 uint8_t transferFlag = PLDM_START_AND_END;
187 uint16_t respCnt = 0x5;
188 std::vector<uint8_t> recordData{1, 2, 3, 4, 5};
189 uint8_t transferCRC = 0;
190
191 auto rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
192 nextDataTransferHndl, transferFlag, respCnt,
193 recordData.data(), transferCRC, nullptr);
194
George Liu684a7162019-12-06 15:10:52 +0800195 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500196}
197
198TEST(GetPDR, testGoodDecodeRequest)
199{
200 std::array<uint8_t, hdrSize + PLDM_GET_PDR_REQ_BYTES> requestMsg{};
201
202 uint32_t recordHndl = 0x32;
203 uint32_t dataTransferHndl = 0x11;
204 uint8_t transferOpFlag = PLDM_GET_FIRSTPART;
205 uint16_t requestCnt = 0x5;
Lei YU065cf762020-02-28 15:31:28 +0800206 uint16_t recordChangeNum = 0x01;
Sampa Misra7fcfb662019-05-08 13:13:53 -0500207
208 uint32_t retRecordHndl = 0;
209 uint32_t retDataTransferHndl = 0;
210 uint8_t retTransferOpFlag = 0;
211 uint16_t retRequestCnt = 0;
212 uint16_t retRecordChangeNum = 0;
213
214 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
215 struct pldm_get_pdr_req* request =
216 reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
217
Lei YU065cf762020-02-28 15:31:28 +0800218 request->record_handle = htole32(recordHndl);
219 request->data_transfer_handle = htole32(dataTransferHndl);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500220 request->transfer_op_flag = transferOpFlag;
Lei YU065cf762020-02-28 15:31:28 +0800221 request->request_count = htole16(requestCnt);
222 request->record_change_number = htole16(recordChangeNum);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500223
224 auto rc = decode_get_pdr_req(
225 req, requestMsg.size() - hdrSize, &retRecordHndl, &retDataTransferHndl,
226 &retTransferOpFlag, &retRequestCnt, &retRecordChangeNum);
227
George Liu684a7162019-12-06 15:10:52 +0800228 EXPECT_EQ(rc, PLDM_SUCCESS);
229 EXPECT_EQ(retRecordHndl, recordHndl);
230 EXPECT_EQ(retDataTransferHndl, dataTransferHndl);
231 EXPECT_EQ(retTransferOpFlag, transferOpFlag);
232 EXPECT_EQ(retRequestCnt, requestCnt);
233 EXPECT_EQ(retRecordChangeNum, recordChangeNum);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500234}
235
236TEST(GetPDR, testBadDecodeRequest)
237{
238 std::array<uint8_t, PLDM_GET_PDR_REQ_BYTES> requestMsg{};
239 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
240
241 auto rc = decode_get_pdr_req(req, requestMsg.size(), NULL, NULL, NULL, NULL,
242 NULL);
243
George Liu684a7162019-12-06 15:10:52 +0800244 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
Sampa Misra7fcfb662019-05-08 13:13:53 -0500245}
George Liu820a9a52019-11-26 14:43:59 +0800246
247TEST(GetPDR, testGoodEncodeRequest)
248{
249 uint32_t record_hndl = 0;
250 uint32_t data_transfer_hndl = 0;
251 uint8_t transfer_op_flag = PLDM_GET_FIRSTPART;
252 uint16_t request_cnt = 20;
253 uint16_t record_chg_num = 0;
254
255 std::vector<uint8_t> requestMsg(hdrSize + PLDM_GET_PDR_REQ_BYTES);
256 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
257
258 auto rc = encode_get_pdr_req(0, record_hndl, data_transfer_hndl,
259 transfer_op_flag, request_cnt, record_chg_num,
260 request, PLDM_GET_PDR_REQ_BYTES);
261 EXPECT_EQ(rc, PLDM_SUCCESS);
262 struct pldm_get_pdr_req* req =
263 reinterpret_cast<struct pldm_get_pdr_req*>(request->payload);
Lei YU065cf762020-02-28 15:31:28 +0800264 EXPECT_EQ(record_hndl, le32toh(req->record_handle));
265 EXPECT_EQ(data_transfer_hndl, le32toh(req->data_transfer_handle));
George Liu820a9a52019-11-26 14:43:59 +0800266 EXPECT_EQ(transfer_op_flag, req->transfer_op_flag);
Lei YU065cf762020-02-28 15:31:28 +0800267 EXPECT_EQ(request_cnt, le16toh(req->request_count));
268 EXPECT_EQ(record_chg_num, le16toh(req->record_change_number));
George Liu820a9a52019-11-26 14:43:59 +0800269}
270
271TEST(GetPDR, testBadEncodeRequest)
272{
273 uint32_t record_hndl = 0;
274 uint32_t data_transfer_hndl = 0;
275 uint8_t transfer_op_flag = PLDM_GET_FIRSTPART;
276 uint16_t request_cnt = 32;
277 uint16_t record_chg_num = 0;
278
279 std::vector<uint8_t> requestMsg(hdrSize + PLDM_GET_PDR_REQ_BYTES);
280 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
281
282 auto rc = encode_get_pdr_req(0, record_hndl, data_transfer_hndl,
283 transfer_op_flag, request_cnt, record_chg_num,
284 nullptr, PLDM_GET_PDR_REQ_BYTES);
285 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
286
287 rc = encode_get_pdr_req(0, record_hndl, data_transfer_hndl,
288 transfer_op_flag, request_cnt, record_chg_num,
289 request, PLDM_GET_PDR_REQ_BYTES + 1);
290 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
291}
292
293TEST(GetPDR, testGoodDecodeResponse)
294{
295 const char* recordData = "123456789";
296 uint8_t completionCode = PLDM_SUCCESS;
297 uint32_t nextRecordHndl = 0;
298 uint32_t nextDataTransferHndl = 0;
299 uint8_t transferFlag = PLDM_END;
300 constexpr uint16_t respCnt = 9;
301 uint8_t transferCRC = 96;
302 size_t recordDataLength = 32;
303 std::array<uint8_t, hdrSize + PLDM_GET_PDR_MIN_RESP_BYTES + respCnt +
304 sizeof(transferCRC)>
305 responseMsg{};
306
307 uint8_t retCompletionCode = 0;
308 uint8_t retRecordData[32] = {0};
309 uint32_t retNextRecordHndl = 0;
310 uint32_t retNextDataTransferHndl = 0;
311 uint8_t retTransferFlag = 0;
312 uint16_t retRespCnt = 0;
313 uint8_t retTransferCRC = 0;
314
315 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
316 struct pldm_get_pdr_resp* resp =
317 reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
318 resp->completion_code = completionCode;
319 resp->next_record_handle = htole32(nextRecordHndl);
320 resp->next_data_transfer_handle = htole32(nextDataTransferHndl);
321 resp->transfer_flag = transferFlag;
322 resp->response_count = htole16(respCnt);
323 memcpy(resp->record_data, recordData, respCnt);
George Liu684a7162019-12-06 15:10:52 +0800324 response->payload[PLDM_GET_PDR_MIN_RESP_BYTES + respCnt] = transferCRC;
George Liu820a9a52019-11-26 14:43:59 +0800325
326 auto rc = decode_get_pdr_resp(
327 response, responseMsg.size() - hdrSize, &retCompletionCode,
328 &retNextRecordHndl, &retNextDataTransferHndl, &retTransferFlag,
329 &retRespCnt, retRecordData, recordDataLength, &retTransferCRC);
330 EXPECT_EQ(rc, PLDM_SUCCESS);
331 EXPECT_EQ(retCompletionCode, completionCode);
332 EXPECT_EQ(retNextRecordHndl, nextRecordHndl);
333 EXPECT_EQ(retNextDataTransferHndl, nextDataTransferHndl);
334 EXPECT_EQ(retTransferFlag, transferFlag);
335 EXPECT_EQ(retRespCnt, respCnt);
336 EXPECT_EQ(retTransferCRC, transferCRC);
337 EXPECT_EQ(0, memcmp(recordData, resp->record_data, respCnt));
338}
339
340TEST(GetPDR, testBadDecodeResponse)
341{
342 const char* recordData = "123456789";
343 uint8_t completionCode = PLDM_SUCCESS;
344 uint32_t nextRecordHndl = 0;
345 uint32_t nextDataTransferHndl = 0;
346 uint8_t transferFlag = PLDM_END;
347 constexpr uint16_t respCnt = 9;
348 uint8_t transferCRC = 96;
349 size_t recordDataLength = 32;
350 std::array<uint8_t, hdrSize + PLDM_GET_PDR_MIN_RESP_BYTES + respCnt +
351 sizeof(transferCRC)>
352 responseMsg{};
353
354 uint8_t retCompletionCode = 0;
George Liu684a7162019-12-06 15:10:52 +0800355 uint8_t retRecordData[32] = {0};
George Liu820a9a52019-11-26 14:43:59 +0800356 uint32_t retNextRecordHndl = 0;
357 uint32_t retNextDataTransferHndl = 0;
358 uint8_t retTransferFlag = 0;
359 uint16_t retRespCnt = 0;
360 uint8_t retTransferCRC = 0;
361
362 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
363 struct pldm_get_pdr_resp* resp =
364 reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
365 resp->completion_code = completionCode;
366 resp->next_record_handle = htole32(nextRecordHndl);
367 resp->next_data_transfer_handle = htole32(nextDataTransferHndl);
368 resp->transfer_flag = transferFlag;
369 resp->response_count = htole16(respCnt);
370 memcpy(resp->record_data, recordData, respCnt);
George Liu684a7162019-12-06 15:10:52 +0800371 response->payload[PLDM_GET_PDR_MIN_RESP_BYTES + respCnt] = transferCRC;
George Liu820a9a52019-11-26 14:43:59 +0800372
373 auto rc = decode_get_pdr_resp(response, responseMsg.size() - hdrSize, NULL,
374 NULL, NULL, NULL, NULL, NULL, 0, NULL);
375 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
376
377 rc = decode_get_pdr_resp(
378 response, responseMsg.size() - hdrSize - 1, &retCompletionCode,
379 &retNextRecordHndl, &retNextDataTransferHndl, &retTransferFlag,
380 &retRespCnt, retRecordData, recordDataLength, &retTransferCRC);
381 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
382}
George Liu30b859f2020-01-07 15:03:22 +0800383
384TEST(SetNumericEffecterValue, testGoodDecodeRequest)
385{
386 std::array<uint8_t,
387 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 3>
388 requestMsg{};
389
390 uint16_t effecter_id = 32768;
391 uint8_t effecter_data_size = PLDM_EFFECTER_DATA_SIZE_UINT32;
392 uint32_t effecter_value = 123456789;
393
394 uint16_t reteffecter_id;
395 uint8_t reteffecter_data_size;
396 uint8_t reteffecter_value[4];
397
398 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
399 struct pldm_set_numeric_effecter_value_req* request =
400 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
401 req->payload);
402
Lei YU065cf762020-02-28 15:31:28 +0800403 request->effecter_id = htole16(effecter_id);
George Liu30b859f2020-01-07 15:03:22 +0800404 request->effecter_data_size = effecter_data_size;
Lei YU065cf762020-02-28 15:31:28 +0800405 uint32_t effecter_value_le = htole32(effecter_value);
406 memcpy(request->effecter_value, &effecter_value_le,
407 sizeof(effecter_value_le));
George Liu30b859f2020-01-07 15:03:22 +0800408
409 auto rc = decode_set_numeric_effecter_value_req(
410 req, requestMsg.size() - hdrSize, &reteffecter_id,
Lei YU065cf762020-02-28 15:31:28 +0800411 &reteffecter_data_size, reteffecter_value);
George Liu30b859f2020-01-07 15:03:22 +0800412
Lei YU065cf762020-02-28 15:31:28 +0800413 uint32_t value = le32toh(*(reinterpret_cast<uint32_t*>(reteffecter_value)));
George Liu30b859f2020-01-07 15:03:22 +0800414 EXPECT_EQ(rc, PLDM_SUCCESS);
415 EXPECT_EQ(reteffecter_id, effecter_id);
416 EXPECT_EQ(reteffecter_data_size, effecter_data_size);
417 EXPECT_EQ(value, effecter_value);
418}
419
420TEST(SetNumericEffecterValue, testBadDecodeRequest)
421{
422 std::array<uint8_t, hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES>
423 requestMsg{};
424
425 auto rc = decode_set_numeric_effecter_value_req(
426 NULL, requestMsg.size() - hdrSize, NULL, NULL, NULL);
427 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
428
429 uint16_t effecter_id = 0x10;
430 uint8_t effecter_data_size = PLDM_EFFECTER_DATA_SIZE_UINT8;
431 uint8_t effecter_value = 1;
432
433 uint16_t reteffecter_id;
434 uint8_t reteffecter_data_size;
435 uint8_t reteffecter_value[4];
436
437 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
438 struct pldm_set_numeric_effecter_value_req* request =
439 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
440 req->payload);
441
442 request->effecter_id = effecter_id;
443 request->effecter_data_size = effecter_data_size;
444 memcpy(request->effecter_value, &effecter_value, sizeof(effecter_value));
445
446 rc = decode_set_numeric_effecter_value_req(
447 req, requestMsg.size() - hdrSize - 1, &reteffecter_id,
448 &reteffecter_data_size, reinterpret_cast<uint8_t*>(&reteffecter_value));
449 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
450}
451
452TEST(SetNumericEffecterValue, testGoodEncodeRequest)
453{
454 uint16_t effecter_id = 0;
455 uint8_t effecter_data_size = PLDM_EFFECTER_DATA_SIZE_UINT8;
456 uint8_t effecter_value = 1;
457
458 std::vector<uint8_t> requestMsg(
459 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
460 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
461
462 auto rc = encode_set_numeric_effecter_value_req(
463 0, effecter_id, effecter_data_size,
464 reinterpret_cast<uint8_t*>(&effecter_value), request,
465 PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
466 EXPECT_EQ(rc, PLDM_SUCCESS);
467
468 struct pldm_set_numeric_effecter_value_req* req =
469 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
470 request->payload);
471 EXPECT_EQ(effecter_id, req->effecter_id);
472 EXPECT_EQ(effecter_data_size, req->effecter_data_size);
473 EXPECT_EQ(effecter_value,
474 *(reinterpret_cast<uint8_t*>(&req->effecter_value[0])));
475}
476
477TEST(SetNumericEffecterValue, testBadEncodeRequest)
478{
479 std::vector<uint8_t> requestMsg(
480 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
481 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
482
483 auto rc = encode_set_numeric_effecter_value_req(
484 0, 0, 0, NULL, NULL, PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
485 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
486
487 uint16_t effecter_value;
488 rc = encode_set_numeric_effecter_value_req(
489 0, 0, 6, reinterpret_cast<uint8_t*>(&effecter_value), request,
490 PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
491 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
492}
493
494TEST(SetNumericEffecterValue, testGoodDecodeResponse)
495{
496 std::array<uint8_t, hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
497 responseMsg{};
498
499 uint8_t completion_code = 0xA0;
500
501 uint8_t retcompletion_code;
502
503 memcpy(responseMsg.data() + hdrSize, &completion_code,
504 sizeof(completion_code));
505
506 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
507
508 auto rc = decode_set_numeric_effecter_value_resp(
509 response, responseMsg.size() - hdrSize, &retcompletion_code);
510
511 EXPECT_EQ(rc, PLDM_SUCCESS);
512 EXPECT_EQ(completion_code, retcompletion_code);
513}
514
515TEST(SetNumericEffecterValue, testBadDecodeResponse)
516{
517 std::array<uint8_t, PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
518 responseMsg{};
519
520 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
521
522 auto rc = decode_set_numeric_effecter_value_resp(response,
523 responseMsg.size(), NULL);
524
525 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
526}
527
528TEST(SetNumericEffecterValue, testGoodEncodeResponse)
529{
530 std::array<uint8_t, sizeof(pldm_msg_hdr) +
531 PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
532 responseMsg{};
533 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
534 uint8_t completionCode = 0;
535
536 auto rc = encode_set_numeric_effecter_value_resp(
537 0, PLDM_SUCCESS, response, PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES);
538
539 EXPECT_EQ(rc, PLDM_SUCCESS);
540 EXPECT_EQ(completionCode, response->payload[0]);
541}
542
543TEST(SetNumericEffecterValue, testBadEncodeResponse)
544{
545 auto rc = encode_set_numeric_effecter_value_resp(
546 0, PLDM_SUCCESS, NULL, PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES);
547 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
548}
Jolie Ku3557bad2020-03-02 16:22:57 +0800549
550TEST(GetStateSensorReadings, testGoodEncodeResponse)
551{
552 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_RESP_BYTES>
553 responseMsg{};
554
555 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
556 uint8_t completionCode = 0;
557 uint8_t comp_sensorCnt = 0x2;
558
559 std::array<get_sensor_state_field, 2> stateField{};
560 stateField[0] = {ENABLED, NORMAL, WARNING, UNKNOWN};
561 stateField[1] = {FAILED, UPPERFATAL, UPPERCRITICAL, FATAL};
562
563 auto rc = encode_get_state_sensor_readings_resp(
564 0, PLDM_SUCCESS, comp_sensorCnt, stateField.data(), response);
565
566 struct pldm_get_state_sensor_readings_resp* resp =
567 reinterpret_cast<struct pldm_get_state_sensor_readings_resp*>(
568 response->payload);
569
570 EXPECT_EQ(rc, PLDM_SUCCESS);
571 EXPECT_EQ(completionCode, resp->completion_code);
572 EXPECT_EQ(comp_sensorCnt, resp->comp_sensor_count);
573 EXPECT_EQ(stateField[0].sensor_op_state, resp->field->sensor_op_state);
574 EXPECT_EQ(stateField[0].present_state, resp->field->present_state);
575 EXPECT_EQ(stateField[0].previous_state, resp->field->previous_state);
576 EXPECT_EQ(stateField[0].event_state, resp->field->event_state);
577 EXPECT_EQ(stateField[1].sensor_op_state, resp->field[1].sensor_op_state);
578 EXPECT_EQ(stateField[1].present_state, resp->field[1].present_state);
579 EXPECT_EQ(stateField[1].previous_state, resp->field[1].previous_state);
580 EXPECT_EQ(stateField[1].event_state, resp->field[1].event_state);
581}
582
583TEST(GetStateSensorReadings, testBadEncodeResponse)
584{
585 auto rc = encode_get_state_sensor_readings_resp(0, PLDM_SUCCESS, 0, nullptr,
586 nullptr);
587
588 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
589}
590
591TEST(GetStateSensorReadings, testGoodDecodeResponse)
592{
593 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_RESP_BYTES>
594 responseMsg{};
595
596 uint8_t completionCode = 0;
597 uint8_t comp_sensorCnt = 2;
598
599 std::array<get_sensor_state_field, 2> stateField{};
600 stateField[0] = {DISABLED, UNKNOWN, UNKNOWN, UNKNOWN};
601 stateField[1] = {ENABLED, LOWERFATAL, LOWERCRITICAL, WARNING};
602
603 uint8_t retcompletion_code = 0;
604 uint8_t retcomp_sensorCnt = 2;
605 std::array<get_sensor_state_field, 2> retstateField{};
606
607 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
608 struct pldm_get_state_sensor_readings_resp* resp =
609 reinterpret_cast<struct pldm_get_state_sensor_readings_resp*>(
610 response->payload);
611
612 resp->completion_code = completionCode;
613 resp->comp_sensor_count = comp_sensorCnt;
614 memcpy(resp->field, &stateField,
615 (sizeof(get_sensor_state_field) * comp_sensorCnt));
616
617 auto rc = decode_get_state_sensor_readings_resp(
618 response, responseMsg.size() - hdrSize, &retcompletion_code,
619 &retcomp_sensorCnt, retstateField.data());
620
621 EXPECT_EQ(rc, PLDM_SUCCESS);
622 EXPECT_EQ(completionCode, retcompletion_code);
623 EXPECT_EQ(comp_sensorCnt, retcomp_sensorCnt);
624 EXPECT_EQ(stateField[0].sensor_op_state, retstateField[0].sensor_op_state);
625 EXPECT_EQ(stateField[0].present_state, retstateField[0].present_state);
626 EXPECT_EQ(stateField[0].previous_state, retstateField[0].previous_state);
627 EXPECT_EQ(stateField[0].event_state, retstateField[0].event_state);
628 EXPECT_EQ(stateField[1].sensor_op_state, retstateField[1].sensor_op_state);
629 EXPECT_EQ(stateField[1].present_state, retstateField[1].present_state);
630 EXPECT_EQ(stateField[1].previous_state, retstateField[1].previous_state);
631 EXPECT_EQ(stateField[1].event_state, retstateField[1].event_state);
632}
633
634TEST(GetStateSensorReadings, testBadDecodeResponse)
635{
636 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_RESP_BYTES>
637 responseMsg{};
638
639 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
640
641 auto rc = decode_get_state_sensor_readings_resp(
642 response, responseMsg.size() - hdrSize, nullptr, nullptr, nullptr);
643
644 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
645
646 uint8_t completionCode = 0;
647 uint8_t comp_sensorCnt = 1;
648
649 std::array<get_sensor_state_field, 1> stateField{};
650 stateField[0] = {ENABLED, UPPERFATAL, UPPERCRITICAL, WARNING};
651
652 uint8_t retcompletion_code = 0;
653 uint8_t retcomp_sensorCnt = 0;
654 std::array<get_sensor_state_field, 1> retstateField{};
655
656 struct pldm_get_state_sensor_readings_resp* resp =
657 reinterpret_cast<struct pldm_get_state_sensor_readings_resp*>(
658 response->payload);
659
660 resp->completion_code = completionCode;
661 resp->comp_sensor_count = comp_sensorCnt;
662 memcpy(resp->field, &stateField,
663 (sizeof(get_sensor_state_field) * comp_sensorCnt));
664
665 rc = decode_get_state_sensor_readings_resp(
666 response, responseMsg.size() - hdrSize, &retcompletion_code,
667 &retcomp_sensorCnt, retstateField.data());
668
669 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
670}
671
672TEST(GetStateSensorReadings, testGoodEncodeRequest)
673{
674 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
675 requestMsg{};
676
677 uint16_t sensorId = 0xAB;
678 bitfield8_t sensorRearm;
679 sensorRearm.byte = 0x03;
680
681 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
682 auto rc = encode_get_state_sensor_readings_req(0, sensorId, sensorRearm, 0,
683 request);
684
685 struct pldm_get_state_sensor_readings_req* req =
686 reinterpret_cast<struct pldm_get_state_sensor_readings_req*>(
687 request->payload);
688
689 EXPECT_EQ(rc, PLDM_SUCCESS);
690 EXPECT_EQ(sensorId, le16toh(req->sensor_id));
691 EXPECT_EQ(sensorRearm.byte, req->sensor_rearm.byte);
692}
693
694TEST(GetStateSensorReadings, testBadEncodeRequest)
695{
696 bitfield8_t sensorRearm;
697 sensorRearm.byte = 0x0;
698
699 auto rc =
700 encode_get_state_sensor_readings_req(0, 0, sensorRearm, 0, nullptr);
701
702 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
703}
704
705TEST(GetStateSensorReadings, testGoodDecodeRequest)
706{
707 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
708 requestMsg{};
709
710 uint16_t sensorId = 0xCD;
711 bitfield8_t sensorRearm;
712 sensorRearm.byte = 0x10;
713
714 uint16_t retsensorId;
715 bitfield8_t retsensorRearm;
716 uint8_t retreserved;
717
718 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
719
720 struct pldm_get_state_sensor_readings_req* req =
721 reinterpret_cast<struct pldm_get_state_sensor_readings_req*>(
722 request->payload);
723
724 req->sensor_id = htole16(sensorId);
725 req->sensor_rearm.byte = sensorRearm.byte;
726
727 auto rc = decode_get_state_sensor_readings_req(
728 request, requestMsg.size() - hdrSize, &retsensorId, &retsensorRearm,
729 &retreserved);
730
731 EXPECT_EQ(rc, PLDM_SUCCESS);
732 EXPECT_EQ(sensorId, retsensorId);
733 EXPECT_EQ(sensorRearm.byte, retsensorRearm.byte);
734 EXPECT_EQ(0, retreserved);
735}
736
737TEST(GetStateSensorReadings, testBadDecodeRequest)
738{
739 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
740 requestMsg{};
741
742 auto rc = decode_get_state_sensor_readings_req(
743 nullptr, requestMsg.size() - hdrSize, nullptr, nullptr, nullptr);
744
745 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
746 uint16_t sensorId = 0x11;
747 bitfield8_t sensorRearm;
748 sensorRearm.byte = 0x04;
749
750 uint16_t retsensorId;
751 bitfield8_t retsensorRearm;
752 uint8_t retreserved;
753
754 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
755
756 struct pldm_get_state_sensor_readings_req* req =
757 reinterpret_cast<struct pldm_get_state_sensor_readings_req*>(
758 request->payload);
759
760 req->sensor_id = htole16(sensorId);
761 req->sensor_rearm.byte = sensorRearm.byte;
762
763 rc = decode_get_state_sensor_readings_req(
764 request, requestMsg.size() - hdrSize - 1, &retsensorId, &retsensorRearm,
765 &retreserved);
766
767 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
768}
Zahed Hossaind4abab12020-02-06 03:36:43 -0600769
770TEST(PlatformEventMessage, testGoodStateSensorDecodeRequest)
771{
772 std::array<uint8_t,
773 hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
774 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES>
775 requestMsg{};
776
777 uint8_t retFormatVersion = 0;
778 uint8_t retTid = 0;
779 uint8_t retEventClass = 0;
780 size_t retEventDataOffset = 0;
781
782 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
783 struct pldm_platform_event_message_req* request =
784 reinterpret_cast<struct pldm_platform_event_message_req*>(req->payload);
785
786 uint8_t formatVersion = 0x01;
787 uint8_t tid = 0x02;
788 // Sensor Event
789 uint8_t eventClass = 0x00;
790
791 request->format_version = formatVersion;
792 request->tid = tid;
793 request->event_class = eventClass;
794 size_t eventDataOffset =
795 sizeof(formatVersion) + sizeof(tid) + sizeof(eventClass);
796
797 auto rc = decode_platform_event_message_req(
798 req, requestMsg.size() - hdrSize, &retFormatVersion, &retTid,
799 &retEventClass, &retEventDataOffset);
800
801 EXPECT_EQ(rc, PLDM_SUCCESS);
802 EXPECT_EQ(retFormatVersion, formatVersion);
803 EXPECT_EQ(retTid, tid);
804 EXPECT_EQ(retEventClass, eventClass);
805 EXPECT_EQ(retEventDataOffset, eventDataOffset);
806}
807
808TEST(PlatformEventMessage, testBadDecodeRequest)
809{
810 const struct pldm_msg* msg = NULL;
811 std::array<uint8_t,
812 hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
813 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES - 1>
814 requestMsg{};
815 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
816 uint8_t retFormatVersion;
817 uint8_t retTid = 0;
818 uint8_t retEventClass = 0;
819 size_t retEventDataOffset;
820
821 auto rc = decode_platform_event_message_req(msg, sizeof(*msg), NULL, NULL,
822 NULL, NULL);
823 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
824
825 rc = decode_platform_event_message_req(
826 req,
827 requestMsg.size() - hdrSize -
828 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES,
829 &retFormatVersion, &retTid, &retEventClass, &retEventDataOffset);
830 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
831}
832
833TEST(PlatformEventMessage, testGoodEncodeResponse)
834{
835 std::array<uint8_t,
836 hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
837 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES - 1>
838 responseMsg{};
839 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
840 uint8_t completionCode = 0;
841 uint8_t instanceId = 0x01;
842 uint8_t status = 1;
843
844 auto rc = encode_platform_event_message_resp(instanceId, PLDM_SUCCESS,
845 status, response);
846
847 EXPECT_EQ(rc, PLDM_SUCCESS);
848 EXPECT_EQ(completionCode, response->payload[0]);
849 EXPECT_EQ(status, response->payload[1]);
850}
851
852TEST(PlatformEventMessage, testBadEncodeResponse)
853{
854 auto rc = encode_platform_event_message_resp(0, PLDM_SUCCESS, 1, NULL);
855 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
856}
Zahed Hossain1c861712020-03-04 08:55:19 -0600857
858TEST(PlatformEventMessage, testGoodSensorEventDataDecodeRequest)
859{
860 std::array<uint8_t, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH +
861 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES>
862 eventDataArr{};
863 uint16_t sensorId = 0x1234;
864 uint8_t sensorEventClassType = PLDM_SENSOR_OP_STATE;
865
866 struct pldm_sensor_event_data* eventData =
867 (struct pldm_sensor_event_data*)eventDataArr.data();
868 eventData->sensor_id = sensorId;
869 eventData->sensor_event_class_type = sensorEventClassType;
870
871 size_t retSensorOpDataOffset;
872 uint16_t retSensorId = 0;
873 uint8_t retSensorEventClassType;
874 size_t sensorOpDataOffset = sizeof(sensorId) + sizeof(sensorEventClassType);
875 auto rc = decode_sensor_event_data(
876 reinterpret_cast<uint8_t*>(eventData), eventDataArr.size(),
877 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
878 EXPECT_EQ(rc, PLDM_SUCCESS);
879 EXPECT_EQ(retSensorId, sensorId);
880 EXPECT_EQ(retSensorEventClassType, sensorEventClassType);
881 EXPECT_EQ(retSensorOpDataOffset, sensorOpDataOffset);
882}
883
884TEST(PlatformEventMessage, testBadSensorEventDataDecodeRequest)
885{
886
887 std::array<uint8_t, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH +
888 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES>
889 eventDataArr{};
890
891 struct pldm_sensor_event_data* eventData =
892 (struct pldm_sensor_event_data*)eventDataArr.data();
893
894 size_t retSensorOpDataOffset;
895 uint16_t retSensorId = 0;
896 uint8_t retSensorEventClassType;
897 auto rc = decode_sensor_event_data(NULL, eventDataArr.size(), &retSensorId,
898 &retSensorEventClassType,
899 &retSensorOpDataOffset);
900 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
901
902 rc = decode_sensor_event_data(
903 reinterpret_cast<uint8_t*>(eventDataArr.data()),
904 eventDataArr.size() -
905 PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH,
906 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
907 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
908
909 eventData->sensor_event_class_type = PLDM_SENSOR_OP_STATE;
910
911 rc = decode_sensor_event_data(
912 reinterpret_cast<uint8_t*>(eventDataArr.data()), eventDataArr.size(),
913 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
914 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
915
916 eventData->sensor_event_class_type = PLDM_STATE_SENSOR_STATE;
917 rc = decode_sensor_event_data(
918 reinterpret_cast<uint8_t*>(eventDataArr.data()), eventDataArr.size(),
919 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
920 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
921
922 eventData->sensor_event_class_type = PLDM_NUMERIC_SENSOR_STATE;
923 rc = decode_sensor_event_data(
924 reinterpret_cast<uint8_t*>(eventDataArr.data()),
925 eventDataArr.size() + 1, &retSensorId, &retSensorEventClassType,
926 &retSensorOpDataOffset);
927 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
928}
929
930TEST(PlatformEventMessage, testGoodSensorOpEventDataDecodeRequest)
931{
932 std::array<uint8_t, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH>
933 eventDataArr{};
934
935 struct pldm_sensor_event_sensor_op_state* sensorData =
936 (struct pldm_sensor_event_sensor_op_state*)eventDataArr.data();
937 uint8_t presentState = PLDM_SENSOR_ENABLED;
938 uint8_t previousState = PLDM_SENSOR_INITIALIZING;
939 sensorData->present_op_state = presentState;
940 sensorData->previous_op_state = previousState;
941
942 uint8_t retPresentState;
943 uint8_t retPreviousState;
944 auto rc = decode_sensor_op_data(reinterpret_cast<uint8_t*>(sensorData),
945 eventDataArr.size(), &retPresentState,
946 &retPreviousState);
947 EXPECT_EQ(rc, PLDM_SUCCESS);
948 EXPECT_EQ(retPresentState, presentState);
949 EXPECT_EQ(retPreviousState, previousState);
950}
951
952TEST(PlatformEventMessage, testBadSensorOpEventDataDecodeRequest)
953{
954 uint8_t presentOpState;
955 uint8_t previousOpState;
956 size_t sensorDataLength = PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH;
957 auto rc = decode_sensor_op_data(NULL, sensorDataLength, &presentOpState,
958 &previousOpState);
959 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
960
961 std::array<uint8_t, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH>
962 sensorData{};
963 rc = decode_sensor_op_data(reinterpret_cast<uint8_t*>(sensorData.data()),
964 sensorDataLength + 1, &presentOpState,
965 &previousOpState);
966 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
967
968 rc = decode_sensor_op_data(reinterpret_cast<uint8_t*>(sensorData.data()),
969 sensorDataLength, nullptr, &previousOpState);
970 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
971}
972
973TEST(PlatformEventMessage, testGoodSensorStateEventDataDecodeRequest)
974{
975 std::array<uint8_t, PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH>
976 eventDataArr{};
977
978 struct pldm_sensor_event_state_sensor_state* sensorData =
979 (struct pldm_sensor_event_state_sensor_state*)eventDataArr.data();
980 uint8_t sensorOffset = 0x02;
981 uint8_t eventState = PLDM_SENSOR_SHUTTINGDOWN;
982 uint8_t previousEventState = PLDM_SENSOR_INTEST;
983 sensorData->sensor_offset = sensorOffset;
984 sensorData->event_state = eventState;
985 sensorData->previous_event_state = previousEventState;
986
987 uint8_t retSensorOffset;
988 uint8_t retEventState;
989 uint8_t retPreviousState;
990 auto rc = decode_state_sensor_data(reinterpret_cast<uint8_t*>(sensorData),
991 eventDataArr.size(), &retSensorOffset,
992 &retEventState, &retPreviousState);
993 EXPECT_EQ(rc, PLDM_SUCCESS);
994 EXPECT_EQ(retSensorOffset, sensorOffset);
995 EXPECT_EQ(retEventState, eventState);
996 EXPECT_EQ(retPreviousState, previousEventState);
997}
998
999TEST(PlatformEventMessage, testBadStateSensorEventDataDecodeRequest)
1000{
1001 uint8_t sensorOffset;
1002 uint8_t eventState;
1003 uint8_t previousEventState;
1004 size_t sensorDataLength = PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH;
1005 auto rc = decode_state_sensor_data(NULL, sensorDataLength, &sensorOffset,
1006 &eventState, &previousEventState);
1007 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1008
1009 std::array<uint8_t, PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH>
1010 sensorData{};
1011 rc = decode_state_sensor_data(reinterpret_cast<uint8_t*>(sensorData.data()),
1012 sensorDataLength - 1, &sensorOffset,
1013 &eventState, &previousEventState);
1014 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1015
1016 rc = decode_state_sensor_data(reinterpret_cast<uint8_t*>(sensorData.data()),
1017 sensorDataLength, &sensorOffset, nullptr,
1018 &previousEventState);
1019 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1020}
1021
1022TEST(PlatformEventMessage, testGoodNumericSensorEventDataDecodeRequest)
1023{
1024 std::array<uint8_t, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH>
1025 eventDataArr{};
1026 struct pldm_sensor_event_numeric_sensor_state* sensorData =
1027 (struct pldm_sensor_event_numeric_sensor_state*)eventDataArr.data();
1028
1029 size_t sensorDataLength =
1030 PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_32BIT_DATA_LENGTH;
1031 uint8_t eventState = PLDM_SENSOR_SHUTTINGDOWN;
1032 uint8_t previousEventState = PLDM_SENSOR_INTEST;
1033 uint8_t sensorDataSize = PLDM_SENSOR_DATA_SIZE_UINT32;
1034 uint32_t presentReading = 305441741;
1035 sensorData->event_state = eventState;
1036 sensorData->previous_event_state = previousEventState;
1037 sensorData->sensor_data_size = sensorDataSize;
1038 sensorData->present_reading[3] =
1039 static_cast<uint8_t>(htole32(presentReading) & (0x000000ff));
1040 sensorData->present_reading[2] =
1041 static_cast<uint8_t>((htole32(presentReading) & (0x0000ff00)) >> 8);
1042 sensorData->present_reading[1] =
1043 static_cast<uint8_t>((htole32(presentReading) & (0x00ff0000)) >> 16);
1044 sensorData->present_reading[0] =
1045 static_cast<uint8_t>((htole32(presentReading) & (0xff000000)) >> 24);
1046
1047 uint8_t retEventState;
1048 uint8_t retPreviousEventState;
1049 uint8_t retSensorDataSize;
1050 uint32_t retPresentReading;
1051
1052 auto rc = decode_numeric_sensor_data(
1053 reinterpret_cast<uint8_t*>(sensorData), sensorDataLength,
1054 &retEventState, &retPreviousEventState, &retSensorDataSize,
1055 &retPresentReading);
1056 EXPECT_EQ(rc, PLDM_SUCCESS);
1057 EXPECT_EQ(retEventState, eventState);
1058 EXPECT_EQ(retPreviousEventState, previousEventState);
1059 EXPECT_EQ(retSensorDataSize, sensorDataSize);
1060 EXPECT_EQ(retPresentReading, presentReading);
1061
1062 int16_t presentReadingNew = -31432;
1063 sensorData->present_reading[1] =
1064 static_cast<uint8_t>(htole16(presentReadingNew) & (0x000000ff));
1065 sensorData->present_reading[0] =
1066 static_cast<uint8_t>((htole16(presentReadingNew) & (0x0000ff00)) >> 8);
1067 sensorDataSize = PLDM_SENSOR_DATA_SIZE_SINT16;
1068 sensorData->sensor_data_size = sensorDataSize;
1069 sensorDataLength = PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_16BIT_DATA_LENGTH;
1070
1071 rc = decode_numeric_sensor_data(reinterpret_cast<uint8_t*>(sensorData),
1072 sensorDataLength, &retEventState,
1073 &retPreviousEventState, &retSensorDataSize,
1074 &retPresentReading);
1075 EXPECT_EQ(rc, PLDM_SUCCESS);
1076 EXPECT_EQ(retEventState, eventState);
1077 EXPECT_EQ(retPreviousEventState, previousEventState);
1078 EXPECT_EQ(retSensorDataSize, sensorDataSize);
1079 EXPECT_EQ(static_cast<int16_t>(retPresentReading), presentReadingNew);
1080}
1081
1082TEST(PlatformEventMessage, testBadNumericSensorEventDataDecodeRequest)
1083{
1084 uint8_t eventState;
1085 uint8_t previousEventState;
1086 uint8_t sensorDataSize;
1087 uint32_t presentReading;
1088 size_t sensorDataLength =
1089 PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH;
1090 auto rc = decode_numeric_sensor_data(NULL, sensorDataLength, &eventState,
1091 &previousEventState, &sensorDataSize,
1092 &presentReading);
1093 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1094
1095 std::array<uint8_t, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH>
1096 sensorData{};
1097 rc = decode_numeric_sensor_data(
1098 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength - 1,
1099 &eventState, &previousEventState, &sensorDataSize, &presentReading);
1100 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1101
1102 struct pldm_sensor_event_numeric_sensor_state* numericSensorData =
1103 (struct pldm_sensor_event_numeric_sensor_state*)sensorData.data();
1104 numericSensorData->sensor_data_size = PLDM_SENSOR_DATA_SIZE_UINT8;
1105 rc = decode_numeric_sensor_data(
1106 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength,
1107 &eventState, &previousEventState, &sensorDataSize, &presentReading);
1108 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1109
1110 numericSensorData->sensor_data_size = PLDM_SENSOR_DATA_SIZE_UINT16;
1111 rc = decode_numeric_sensor_data(
1112 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength,
1113 &eventState, &previousEventState, &sensorDataSize, &presentReading);
1114 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1115
1116 numericSensorData->sensor_data_size = PLDM_SENSOR_DATA_SIZE_UINT32;
1117 rc = decode_numeric_sensor_data(
1118 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength - 1,
1119 &eventState, &previousEventState, &sensorDataSize, &presentReading);
1120 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1121}