blob: 1958ca03b6f60304b0a9739ac87b6dddf0e5d075 [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
George Liuda75abe2020-04-09 13:36:13 +0800413 uint32_t value = *(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;
Pavithra Barithaya2ea1f072020-04-03 09:30:23 -0500842 uint8_t platformEventStatus = 0x01;
Zahed Hossaind4abab12020-02-06 03:36:43 -0600843
844 auto rc = encode_platform_event_message_resp(instanceId, PLDM_SUCCESS,
Pavithra Barithaya2ea1f072020-04-03 09:30:23 -0500845 platformEventStatus, response);
Zahed Hossaind4abab12020-02-06 03:36:43 -0600846
847 EXPECT_EQ(rc, PLDM_SUCCESS);
848 EXPECT_EQ(completionCode, response->payload[0]);
Pavithra Barithaya2ea1f072020-04-03 09:30:23 -0500849 EXPECT_EQ(platformEventStatus, response->payload[1]);
Zahed Hossaind4abab12020-02-06 03:36:43 -0600850}
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}
Jolie Ku6787f172020-03-19 11:15:53 +08001122
1123TEST(GetNumericEffecterValue, testGoodEncodeRequest)
1124{
1125 std::vector<uint8_t> requestMsg(hdrSize +
1126 PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES);
1127
1128 uint16_t effecter_id = 0xAB01;
1129
1130 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1131
1132 auto rc = encode_get_numeric_effecter_value_req(0, effecter_id, request);
1133
1134 struct pldm_get_numeric_effecter_value_req* req =
1135 reinterpret_cast<struct pldm_get_numeric_effecter_value_req*>(
1136 request->payload);
1137
1138 EXPECT_EQ(rc, PLDM_SUCCESS);
1139 EXPECT_EQ(effecter_id, le16toh(req->effecter_id));
1140}
1141
1142TEST(GetNumericEffecterValue, testBadEncodeRequest)
1143{
1144 std::vector<uint8_t> requestMsg(
1145 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
1146
1147 auto rc = encode_get_numeric_effecter_value_req(0, 0, nullptr);
1148 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1149}
1150
1151TEST(GetNumericEffecterValue, testGoodDecodeRequest)
1152{
1153 std::array<uint8_t, hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES>
1154 requestMsg{};
1155
1156 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1157 struct pldm_get_numeric_effecter_value_req* req =
1158 reinterpret_cast<struct pldm_get_numeric_effecter_value_req*>(
1159 request->payload);
1160
1161 uint16_t effecter_id = 0x12AB;
1162 req->effecter_id = htole16(effecter_id);
1163
1164 uint16_t reteffecter_id;
1165
1166 auto rc = decode_get_numeric_effecter_value_req(
1167 request, requestMsg.size() - hdrSize, &reteffecter_id);
1168
1169 EXPECT_EQ(rc, PLDM_SUCCESS);
1170 EXPECT_EQ(effecter_id, reteffecter_id);
1171}
1172
1173TEST(GetNumericEffecterValue, testBadDecodeRequest)
1174{
1175 std::array<uint8_t, hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES>
1176 requestMsg{};
1177
1178 auto rc = decode_get_numeric_effecter_value_req(
1179 nullptr, requestMsg.size() - hdrSize, nullptr);
1180
1181 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1182
1183 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1184 struct pldm_set_numeric_effecter_value_req* req =
1185 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
1186 request->payload);
1187
1188 uint16_t effecter_id = 0x1A;
1189 req->effecter_id = htole16(effecter_id);
1190 uint16_t reteffecter_id;
1191
1192 rc = decode_get_numeric_effecter_value_req(
1193 request, requestMsg.size() - hdrSize - 1, &reteffecter_id);
1194
1195 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1196}
1197
1198TEST(GetNumericEffecterValue, testGoodEncodeResponse)
1199{
1200 uint8_t completionCode = 0;
1201 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT32;
1202 uint8_t effecter_operState = EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING;
1203 uint32_t pendingValue = 0x12345678;
1204 uint32_t presentValue = 0xABCDEF00;
1205
1206 std::array<uint8_t,
1207 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 6>
1208 responseMsg{};
1209 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1210
1211 uint32_t pendingValue_le = htole32(pendingValue);
1212 uint32_t presentValue_le = htole32(presentValue);
1213
1214 auto rc = encode_get_numeric_effecter_value_resp(
1215 0, completionCode, effecter_dataSize, effecter_operState,
1216 reinterpret_cast<uint8_t*>(&pendingValue_le),
1217 reinterpret_cast<uint8_t*>(&presentValue_le), response,
1218 responseMsg.size() - hdrSize);
1219
1220 struct pldm_get_numeric_effecter_value_resp* resp =
1221 reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
1222 response->payload);
1223
1224 EXPECT_EQ(rc, PLDM_SUCCESS);
1225 EXPECT_EQ(effecter_dataSize, resp->effecter_data_size);
1226 EXPECT_EQ(effecter_operState, resp->effecter_oper_state);
1227 EXPECT_EQ(pendingValue, le32toh(*(reinterpret_cast<uint32_t*>(
1228 &resp->pending_and_present_values[0]))));
1229 EXPECT_EQ(presentValue, le32toh(*(reinterpret_cast<uint32_t*>(
1230 &resp->pending_and_present_values[4]))));
1231}
1232
1233TEST(GetNumericEffecterValue, testBadEncodeResponse)
1234{
1235 std::array<uint8_t,
1236 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 2>
1237 responseMsg{};
1238 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1239
1240 uint8_t pendingValue = 0x01;
1241 uint8_t presentValue = 0x02;
1242
1243 auto rc = encode_get_numeric_effecter_value_resp(
1244 0, PLDM_SUCCESS, 0, 0, nullptr, nullptr, nullptr,
1245 responseMsg.size() - hdrSize);
1246 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1247
1248 rc = encode_get_numeric_effecter_value_resp(
1249 0, PLDM_SUCCESS, 6, 9, reinterpret_cast<uint8_t*>(&pendingValue),
1250 reinterpret_cast<uint8_t*>(&presentValue), response,
1251 responseMsg.size() - hdrSize);
1252 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1253
1254 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT8;
1255 uint8_t effecter_operState = EFFECTER_OPER_STATE_FAILED;
1256
1257 rc = encode_get_numeric_effecter_value_resp(
1258 0, PLDM_SUCCESS, effecter_dataSize, effecter_operState,
1259 reinterpret_cast<uint8_t*>(&pendingValue),
1260 reinterpret_cast<uint8_t*>(&presentValue), response,
1261 responseMsg.size() - hdrSize);
1262 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1263}
1264
1265TEST(GetNumericEffecterValue, testGoodDecodeResponse)
1266{
1267 std::array<uint8_t,
1268 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 2>
1269 responseMsg{};
1270
1271 uint8_t completionCode = 0;
1272 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT16;
1273 uint8_t effecter_operState = EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING;
1274 uint16_t pendingValue = 0x4321;
1275 uint16_t presentValue = 0xDCBA;
1276
1277 uint8_t retcompletionCode;
1278 uint8_t reteffecter_dataSize;
1279 uint8_t reteffecter_operState;
1280 uint8_t retpendingValue[2];
1281 uint8_t retpresentValue[2];
1282
1283 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1284 struct pldm_get_numeric_effecter_value_resp* resp =
1285 reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
1286 response->payload);
1287
1288 resp->completion_code = completionCode;
1289 resp->effecter_data_size = effecter_dataSize;
1290 resp->effecter_oper_state = effecter_operState;
1291
1292 uint16_t pendingValue_le = htole16(pendingValue);
1293 memcpy(resp->pending_and_present_values, &pendingValue_le,
1294 sizeof(pendingValue_le));
1295 uint16_t presentValue_le = htole16(presentValue);
1296 memcpy(&resp->pending_and_present_values[2], &presentValue_le,
1297 sizeof(presentValue_le));
1298
1299 auto rc = decode_get_numeric_effecter_value_resp(
1300 response, responseMsg.size() - hdrSize, &retcompletionCode,
1301 &reteffecter_dataSize, &reteffecter_operState, retpendingValue,
1302 retpresentValue);
1303
1304 uint16_t retpending_value =
1305 le16toh(*(reinterpret_cast<uint16_t*>(retpendingValue)));
1306 uint16_t retpresent_value =
1307 le16toh(*(reinterpret_cast<uint16_t*>(retpresentValue)));
1308
1309 EXPECT_EQ(rc, PLDM_SUCCESS);
1310 EXPECT_EQ(completionCode, retcompletionCode);
1311 EXPECT_EQ(effecter_dataSize, reteffecter_dataSize);
1312 EXPECT_EQ(effecter_operState, reteffecter_operState);
1313 EXPECT_EQ(pendingValue, retpending_value);
1314 EXPECT_EQ(presentValue, retpresent_value);
1315}
1316
1317TEST(GetNumericEffecterValue, testBadDecodeResponse)
1318{
1319 std::array<uint8_t,
1320 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 6>
1321 responseMsg{};
1322
1323 auto rc = decode_get_numeric_effecter_value_resp(
1324 nullptr, responseMsg.size() - hdrSize, nullptr, nullptr, nullptr,
1325 nullptr, nullptr);
1326
1327 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1328
1329 uint8_t completionCode = 0;
1330 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_SINT16;
1331 uint8_t effecter_operState = EFFECTER_OPER_STATE_DISABLED;
1332 uint16_t pendingValue = 0x5678;
1333 uint16_t presentValue = 0xCDEF;
1334
1335 uint8_t retcompletionCode;
1336 uint8_t reteffecter_dataSize;
1337 uint8_t reteffecter_operState;
1338 uint8_t retpendingValue[2];
1339 uint8_t retpresentValue[2];
1340
1341 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1342 struct pldm_get_numeric_effecter_value_resp* resp =
1343 reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
1344 response->payload);
1345
1346 resp->completion_code = completionCode;
1347 resp->effecter_data_size = effecter_dataSize;
1348 resp->effecter_oper_state = effecter_operState;
1349
1350 uint16_t pendingValue_le = htole16(pendingValue);
1351 memcpy(resp->pending_and_present_values, &pendingValue_le,
1352 sizeof(pendingValue_le));
1353 uint16_t presentValue_le = htole16(presentValue);
1354 memcpy(&resp->pending_and_present_values[2], &presentValue_le,
1355 sizeof(presentValue_le));
1356
1357 rc = decode_get_numeric_effecter_value_resp(
1358 response, responseMsg.size() - hdrSize, &retcompletionCode,
1359 &reteffecter_dataSize, &reteffecter_operState, retpendingValue,
1360 retpresentValue);
1361
1362 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1363}
Zahed Hossain9be087c2020-04-02 02:26:41 -05001364
1365TEST(PldmPDRRepositoryChgEventEvent, testGoodDecodeRequest)
1366{
1367 const uint8_t eventDataFormat = FORMAT_IS_PDR_HANDLES;
1368 const uint8_t numberOfChangeRecords = 2;
1369 uint8_t eventDataOperation1 = PLDM_RECORDS_DELETED;
1370 const uint8_t numberOfChangeEntries1 = 2;
1371 std::array<uint32_t, numberOfChangeEntries1> changeRecordArr1{
1372 {0x00000000, 0x12345678}};
1373 uint8_t eventDataOperation2 = PLDM_RECORDS_ADDED;
1374 const uint8_t numberOfChangeEntries2 = 5;
1375 std::array<uint32_t, numberOfChangeEntries2> changeRecordArr2{
1376 {0x01234567, 0x11223344, 0x45678901, 0x21222324, 0x98765432}};
1377 std::array<uint8_t, PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH +
1378 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH *
1379 numberOfChangeRecords +
1380 (numberOfChangeEntries1 + numberOfChangeEntries2) *
1381 sizeof(uint32_t)>
1382 eventDataArr{};
1383
1384 struct pldm_pdr_repository_chg_event_data* eventData =
1385 reinterpret_cast<struct pldm_pdr_repository_chg_event_data*>(
1386 eventDataArr.data());
1387 eventData->event_data_format = eventDataFormat;
1388 eventData->number_of_change_records = numberOfChangeRecords;
1389 struct pldm_pdr_repository_change_record_data* changeRecord1 =
1390 reinterpret_cast<struct pldm_pdr_repository_change_record_data*>(
1391 eventData->change_records);
1392 changeRecord1->event_data_operation = eventDataOperation1;
1393 changeRecord1->number_of_change_entries = numberOfChangeEntries1;
1394 memcpy(changeRecord1->change_entry, &changeRecordArr1[0],
1395 changeRecordArr1.size() * sizeof(uint32_t));
1396 struct pldm_pdr_repository_change_record_data* changeRecord2 =
1397 reinterpret_cast<struct pldm_pdr_repository_change_record_data*>(
1398 eventData->change_records +
1399 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH +
1400 (changeRecordArr1.size() * sizeof(uint32_t)));
1401 changeRecord2->event_data_operation = eventDataOperation2;
1402 changeRecord2->number_of_change_entries = numberOfChangeEntries2;
1403 memcpy(changeRecord2->change_entry, &changeRecordArr2[0],
1404 changeRecordArr2.size() * sizeof(uint32_t));
1405
1406 uint8_t retEventDataFormat{};
1407 uint8_t retNumberOfChangeRecords{};
1408 size_t retChangeRecordDataOffset{0};
1409 auto rc = decode_pldm_pdr_repository_chg_event_data(
1410 reinterpret_cast<const uint8_t*>(eventData), eventDataArr.size(),
1411 &retEventDataFormat, &retNumberOfChangeRecords,
1412 &retChangeRecordDataOffset);
1413 EXPECT_EQ(rc, PLDM_SUCCESS);
1414 EXPECT_EQ(retEventDataFormat, FORMAT_IS_PDR_HANDLES);
1415 EXPECT_EQ(retNumberOfChangeRecords, numberOfChangeRecords);
1416
1417 const uint8_t* changeRecordData =
1418 reinterpret_cast<const uint8_t*>(changeRecord1);
1419 size_t changeRecordDataSize =
1420 eventDataArr.size() - PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH;
1421 uint8_t retEventDataOperation;
1422 uint8_t retNumberOfChangeEntries;
1423 size_t retChangeEntryDataOffset;
1424
1425 rc = decode_pldm_pdr_repository_change_record_data(
1426 reinterpret_cast<const uint8_t*>(changeRecordData),
1427 changeRecordDataSize, &retEventDataOperation, &retNumberOfChangeEntries,
1428 &retChangeEntryDataOffset);
1429 EXPECT_EQ(rc, PLDM_SUCCESS);
1430 EXPECT_EQ(retEventDataOperation, eventDataOperation1);
1431 EXPECT_EQ(retNumberOfChangeEntries, numberOfChangeEntries1);
1432 changeRecordData += retChangeEntryDataOffset;
1433 EXPECT_EQ(0, memcmp(changeRecordData, &changeRecordArr1[0],
1434 sizeof(uint32_t) * retNumberOfChangeEntries));
1435
1436 changeRecordData += sizeof(uint32_t) * retNumberOfChangeEntries;
1437 changeRecordDataSize -= sizeof(uint32_t) * retNumberOfChangeEntries -
1438 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH;
1439 rc = decode_pldm_pdr_repository_change_record_data(
1440 reinterpret_cast<const uint8_t*>(changeRecordData),
1441 changeRecordDataSize, &retEventDataOperation, &retNumberOfChangeEntries,
1442 &retChangeEntryDataOffset);
1443 EXPECT_EQ(rc, PLDM_SUCCESS);
1444 EXPECT_EQ(retEventDataOperation, eventDataOperation2);
1445 EXPECT_EQ(retNumberOfChangeEntries, numberOfChangeEntries2);
1446 changeRecordData += retChangeEntryDataOffset;
1447 EXPECT_EQ(0, memcmp(changeRecordData, &changeRecordArr2[0],
1448 sizeof(uint32_t) * retNumberOfChangeEntries));
1449}
1450
1451TEST(PldmPDRRepositoryChgEventEvent, testBadDecodeRequest)
1452{
1453 uint8_t eventDataFormat{};
1454 uint8_t numberOfChangeRecords{};
1455 size_t changeRecordDataOffset{};
1456 auto rc = decode_pldm_pdr_repository_chg_event_data(
1457 NULL, 0, &eventDataFormat, &numberOfChangeRecords,
1458 &changeRecordDataOffset);
1459 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1460
1461 std::array<uint8_t, 2> eventData{};
1462 rc = decode_pldm_pdr_repository_chg_event_data(
1463 reinterpret_cast<const uint8_t*>(eventData.data()), 0, &eventDataFormat,
1464 &numberOfChangeRecords, &changeRecordDataOffset);
1465 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1466
1467 uint8_t eventDataOperation{};
1468 uint8_t numberOfChangeEntries{};
1469 size_t changeEntryDataOffset{};
1470 rc = decode_pldm_pdr_repository_change_record_data(
1471 NULL, 0, &eventDataOperation, &numberOfChangeEntries,
1472 &changeEntryDataOffset);
1473 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1474
1475 std::array<uint8_t, 2> changeRecord{};
1476 rc = decode_pldm_pdr_repository_change_record_data(
1477 reinterpret_cast<const uint8_t*>(changeRecord.data()), 0,
1478 &eventDataOperation, &numberOfChangeEntries, &changeEntryDataOffset);
1479 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1480}