1 #include <endian.h>
2 #include <libpldm/base.h>
3 #include <libpldm/oem/ibm/file_io.h>
4
5 #include <array>
6 #include <cstdint>
7 #include <cstring>
8 #include <vector>
9
10 #include <gtest/gtest.h>
11
12 constexpr auto hdrSize = sizeof(pldm_msg_hdr);
13
TEST(ReadWriteFileMemory,testGoodDecodeRequest)14 TEST(ReadWriteFileMemory, testGoodDecodeRequest)
15 {
16 std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES + hdrSize> requestMsg{};
17
18 // Random value for fileHandle, offset, length, address
19 uint32_t fileHandle = 0x12345678;
20 uint32_t offset = 0x87654321;
21 uint32_t length = 0x13245768;
22 uint64_t address = 0x124356879acbde0f;
23 uint32_t fileHandleLe = htole32(fileHandle);
24 uint32_t offsetLe = htole32(offset);
25 uint32_t lengthLe = htole32(length);
26 uint64_t addressLe = htole64(address);
27
28 memcpy(requestMsg.data() + hdrSize, &fileHandleLe, sizeof(fileHandleLe));
29 memcpy(requestMsg.data() + sizeof(fileHandleLe) + hdrSize, &offsetLe,
30 sizeof(offsetLe));
31 memcpy(requestMsg.data() + sizeof(fileHandleLe) + sizeof(offsetLe) +
32 hdrSize,
33 &lengthLe, sizeof(lengthLe));
34 memcpy(requestMsg.data() + sizeof(fileHandleLe) + sizeof(offsetLe) +
35 sizeof(lengthLe) + hdrSize,
36 &addressLe, sizeof(addressLe));
37
38 uint32_t retFileHandle = 0;
39 uint32_t retOffset = 0;
40 uint32_t retLength = 0;
41 uint64_t retAddress = 0;
42
43 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
44 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
45
46 // Invoke decode the read file memory request
47 auto rc = decode_rw_file_memory_req(request, requestMsg.size() - hdrSize,
48 &retFileHandle, &retOffset, &retLength,
49 &retAddress);
50
51 ASSERT_EQ(rc, PLDM_SUCCESS);
52 ASSERT_EQ(fileHandle, retFileHandle);
53 ASSERT_EQ(offset, retOffset);
54 ASSERT_EQ(length, retLength);
55 ASSERT_EQ(address, retAddress);
56 }
57
TEST(ReadWriteFileMemory,testBadDecodeRequest)58 TEST(ReadWriteFileMemory, testBadDecodeRequest)
59 {
60 uint32_t fileHandle = 0;
61 uint32_t offset = 0;
62 uint32_t length = 0;
63 uint64_t address = 0;
64
65 // Request payload message is missing
66 auto rc = decode_rw_file_memory_req(NULL, 0, &fileHandle, &offset, &length,
67 &address);
68 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
69
70 std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
71
72 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
73 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
74
75 // Address is NULL
76 rc = decode_rw_file_memory_req(request, requestMsg.size() - hdrSize,
77 &fileHandle, &offset, &length, NULL);
78 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
79
80 // Payload length is invalid
81 rc = decode_rw_file_memory_req(request, 0, &fileHandle, &offset, &length,
82 &address);
83 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
84 }
85
TEST(ReadWriteFileMemory,testGoodEncodeResponse)86 TEST(ReadWriteFileMemory, testGoodEncodeResponse)
87 {
88 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
89 responseMsg{};
90 uint32_t length = 0xff00ee11;
91 uint32_t lengthLe = htole32(length);
92 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
93 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
94
95 // ReadFileIntoMemory
96 auto rc = encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
97 PLDM_SUCCESS, length, response);
98
99 ASSERT_EQ(rc, PLDM_SUCCESS);
100 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
101 ASSERT_EQ(response->hdr.instance_id, 0);
102 ASSERT_EQ(response->hdr.type, PLDM_OEM);
103 ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_INTO_MEMORY);
104 ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
105 ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
106 &lengthLe, sizeof(lengthLe)));
107
108 // WriteFileFromMemory
109 rc = encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
110 PLDM_SUCCESS, length, response);
111
112 ASSERT_EQ(rc, PLDM_SUCCESS);
113 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
114 ASSERT_EQ(response->hdr.instance_id, 0);
115 ASSERT_EQ(response->hdr.type, PLDM_OEM);
116 ASSERT_EQ(response->hdr.command, PLDM_WRITE_FILE_FROM_MEMORY);
117 ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
118 ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
119 &lengthLe, sizeof(lengthLe)));
120 }
121
TEST(ReadWriteFileMemory,testBadEncodeResponse)122 TEST(ReadWriteFileMemory, testBadEncodeResponse)
123 {
124 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
125 responseMsg{};
126 uint32_t length = 0;
127 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
128 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
129
130 // ReadFileIntoMemory
131 auto rc = encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
132 PLDM_ERROR, length, response);
133
134 ASSERT_EQ(rc, PLDM_SUCCESS);
135 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
136 ASSERT_EQ(response->hdr.instance_id, 0);
137 ASSERT_EQ(response->hdr.type, PLDM_OEM);
138 ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_INTO_MEMORY);
139 ASSERT_EQ(response->payload[0], PLDM_ERROR);
140
141 // WriteFileFromMemory
142 rc = encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY, PLDM_ERROR,
143 length, response);
144
145 ASSERT_EQ(rc, PLDM_SUCCESS);
146 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
147 ASSERT_EQ(response->hdr.instance_id, 0);
148 ASSERT_EQ(response->hdr.type, PLDM_OEM);
149 ASSERT_EQ(response->hdr.command, PLDM_WRITE_FILE_FROM_MEMORY);
150 ASSERT_EQ(response->payload[0], PLDM_ERROR);
151 }
152
TEST(ReadWriteFileIntoMemory,testGoodDecodeResponse)153 TEST(ReadWriteFileIntoMemory, testGoodDecodeResponse)
154 {
155 std::array<uint8_t, PLDM_RW_FILE_MEM_RESP_BYTES + hdrSize> responseMsg{};
156 // Random value for length
157 uint32_t length = 0xff00ee12;
158 uint32_t lengthLe = htole32(length);
159 uint8_t completionCode = 0;
160
161 memcpy(responseMsg.data() + hdrSize, &completionCode,
162 sizeof(completionCode));
163 memcpy(responseMsg.data() + sizeof(completionCode) + hdrSize, &lengthLe,
164 sizeof(lengthLe));
165
166 uint8_t retCompletionCode = 0;
167 uint32_t retLength = 0;
168
169 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
170 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
171
172 // Invoke decode the read file memory response
173 auto rc = decode_rw_file_memory_resp(response, responseMsg.size() - hdrSize,
174 &retCompletionCode, &retLength);
175 ASSERT_EQ(rc, PLDM_SUCCESS);
176 ASSERT_EQ(completionCode, retCompletionCode);
177 ASSERT_EQ(length, retLength);
178 }
179
TEST(ReadWriteFileIntoMemory,testBadDecodeResponse)180 TEST(ReadWriteFileIntoMemory, testBadDecodeResponse)
181 {
182 uint32_t length = 0;
183 uint8_t completionCode = 0;
184
185 // Request payload message is missing
186 auto rc = decode_rw_file_memory_resp(NULL, 0, &completionCode, &length);
187 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
188
189 std::array<uint8_t, PLDM_RW_FILE_MEM_RESP_BYTES> responseMsg{};
190
191 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
192 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
193
194 // Payload length is invalid
195 rc = decode_rw_file_memory_resp(response, 0, &completionCode, &length);
196 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
197 }
198
TEST(ReadWriteFileIntoMemory,testGoodEncodeRequest)199 TEST(ReadWriteFileIntoMemory, testGoodEncodeRequest)
200 {
201 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_REQ_BYTES>
202 requestMsg{};
203
204 uint32_t fileHandle = 0x12345678;
205 uint32_t offset = 0x87654321;
206 uint32_t length = 0x13245768;
207 uint64_t address = 0x124356879acbde0f;
208 uint32_t fileHandleLe = htole32(fileHandle);
209 uint32_t offsetLe = htole32(offset);
210 uint32_t lengthLe = htole32(length);
211 uint64_t addressLe = htole64(address);
212
213 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
214 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
215
216 auto rc =
217 encode_rw_file_memory_req(0, PLDM_READ_FILE_INTO_MEMORY, fileHandle,
218 offset, length, address, request);
219
220 ASSERT_EQ(rc, PLDM_SUCCESS);
221 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
222 ASSERT_EQ(request->hdr.instance_id, 0);
223 ASSERT_EQ(request->hdr.type, PLDM_OEM);
224 ASSERT_EQ(request->hdr.command, PLDM_READ_FILE_INTO_MEMORY);
225
226 ASSERT_EQ(0, memcmp(request->payload, &fileHandleLe, sizeof(fileHandleLe)));
227
228 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileHandleLe), &offsetLe,
229 sizeof(offsetLe)));
230 ASSERT_EQ(0,
231 memcmp(request->payload + sizeof(fileHandleLe) + sizeof(offsetLe),
232 &lengthLe, sizeof(lengthLe)));
233 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileHandleLe) +
234 sizeof(offsetLe) + sizeof(lengthLe),
235 &addressLe, sizeof(addressLe)));
236 }
237
TEST(ReadWriteFileIntoMemory,testBadEncodeRequest)238 TEST(ReadWriteFileIntoMemory, testBadEncodeRequest)
239 {
240 uint32_t fileHandle = 0;
241 uint32_t offset = 0;
242 uint32_t length = 0;
243 uint64_t address = 0;
244
245 auto rc =
246 encode_rw_file_memory_req(0, PLDM_READ_FILE_INTO_MEMORY, fileHandle,
247 offset, length, address, NULL);
248
249 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
250 }
251
TEST(GetFileTable,GoodDecodeRequest)252 TEST(GetFileTable, GoodDecodeRequest)
253 {
254 std::array<uint8_t, PLDM_GET_FILE_TABLE_REQ_BYTES + hdrSize> requestMsg{};
255
256 // Random value for DataTransferHandle, TransferOperationFlag, TableType
257 uint32_t transferHandle = 0x12345678;
258 uint32_t transferHandleLe = htole32(transferHandle);
259 uint8_t transferOpFlag = 1;
260 uint8_t tableType = 1;
261
262 memcpy(requestMsg.data() + hdrSize, &transferHandleLe,
263 sizeof(transferHandleLe));
264 memcpy(requestMsg.data() + sizeof(transferHandle) + hdrSize,
265 &transferOpFlag, sizeof(transferOpFlag));
266 memcpy(requestMsg.data() + sizeof(transferHandle) + sizeof(transferOpFlag) +
267 hdrSize,
268 &tableType, sizeof(tableType));
269
270 uint32_t retTransferHandle = 0;
271 uint8_t retTransferOpFlag = 0;
272 uint8_t retTableType = 0;
273
274 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
275 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
276
277 // Invoke decode get file table request
278 auto rc = decode_get_file_table_req(request, requestMsg.size() - hdrSize,
279 &retTransferHandle, &retTransferOpFlag,
280 &retTableType);
281
282 ASSERT_EQ(rc, PLDM_SUCCESS);
283 ASSERT_EQ(transferHandle, retTransferHandle);
284 ASSERT_EQ(transferOpFlag, retTransferOpFlag);
285 ASSERT_EQ(tableType, retTableType);
286 }
287
TEST(GetFileTable,BadDecodeRequest)288 TEST(GetFileTable, BadDecodeRequest)
289 {
290 uint32_t transferHandle = 0;
291 uint8_t transferOpFlag = 0;
292 uint8_t tableType = 0;
293
294 // Request payload message is missing
295 auto rc = decode_get_file_table_req(nullptr, 0, &transferHandle,
296 &transferOpFlag, &tableType);
297 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
298
299 std::array<uint8_t, PLDM_GET_FILE_TABLE_REQ_BYTES> requestMsg{};
300
301 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
302 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
303
304 // TableType is NULL
305 rc = decode_get_file_table_req(request, requestMsg.size() - hdrSize,
306 &transferHandle, &transferOpFlag, nullptr);
307 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
308
309 // Payload length is invalid
310 rc = decode_get_file_table_req(request, 0, &transferHandle, &transferOpFlag,
311 &tableType);
312 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
313 }
314
TEST(GetFileTable,GoodEncodeResponse)315 TEST(GetFileTable, GoodEncodeResponse)
316 {
317 // Random value for NextDataTransferHandle and TransferFlag
318 uint8_t completionCode = 0;
319 uint32_t nextTransferHandle = 0x87654321;
320 uint32_t nextTransferHandleLe = htole32(nextTransferHandle);
321 uint8_t transferFlag = 5;
322 // Mock file table contents of size 5
323 std::array<uint8_t, 5> fileTable = {1, 2, 3, 4, 5};
324 constexpr size_t responseSize = sizeof(completionCode) +
325 sizeof(nextTransferHandle) +
326 sizeof(transferFlag) + fileTable.size();
327
328 std::array<uint8_t, sizeof(pldm_msg_hdr) + responseSize> responseMsg{};
329 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
330 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
331
332 // GetFileTable
333 auto rc = encode_get_file_table_resp(0, PLDM_SUCCESS, nextTransferHandle,
334 transferFlag, fileTable.data(),
335 fileTable.size(), response);
336
337 ASSERT_EQ(rc, PLDM_SUCCESS);
338 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
339 ASSERT_EQ(response->hdr.instance_id, 0);
340 ASSERT_EQ(response->hdr.type, PLDM_OEM);
341 ASSERT_EQ(response->hdr.command, PLDM_GET_FILE_TABLE);
342 ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
343 ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
344 &nextTransferHandleLe, sizeof(nextTransferHandle)));
345 ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
346 sizeof(nextTransferHandle),
347 &transferFlag, sizeof(transferFlag)));
348 ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
349 sizeof(nextTransferHandle),
350 &transferFlag, sizeof(transferFlag)));
351 ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]) +
352 sizeof(nextTransferHandle) + sizeof(transferFlag),
353 fileTable.data(), fileTable.size()));
354 }
355
TEST(GetFileTable,BadEncodeResponse)356 TEST(GetFileTable, BadEncodeResponse)
357 {
358 uint8_t completionCode = 0;
359 uint32_t nextTransferHandle = 0;
360 uint8_t transferFlag = 0;
361 constexpr size_t responseSize = sizeof(completionCode) +
362 sizeof(nextTransferHandle) +
363 sizeof(transferFlag);
364
365 std::array<uint8_t, sizeof(pldm_msg_hdr) + responseSize> responseMsg{};
366 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
367 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
368
369 // GetFileTable
370 auto rc = encode_get_file_table_resp(0, PLDM_ERROR, nextTransferHandle,
371 transferFlag, nullptr, 0, response);
372
373 ASSERT_EQ(rc, PLDM_SUCCESS);
374 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
375 ASSERT_EQ(response->hdr.instance_id, 0);
376 ASSERT_EQ(response->hdr.type, PLDM_OEM);
377 ASSERT_EQ(response->hdr.command, PLDM_GET_FILE_TABLE);
378 ASSERT_EQ(response->payload[0], PLDM_ERROR);
379 }
380
TEST(GetFileTable,GoodEncodeRequest)381 TEST(GetFileTable, GoodEncodeRequest)
382 {
383 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_FILE_TABLE_REQ_BYTES>
384 requestMsg{};
385 uint32_t transferHandle = 0x0;
386 uint8_t transferOpFlag = 0x01;
387 uint8_t tableType = PLDM_FILE_ATTRIBUTE_TABLE;
388
389 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
390 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
391 auto rc = encode_get_file_table_req(0, transferHandle, transferOpFlag,
392 tableType, request);
393 EXPECT_EQ(rc, PLDM_SUCCESS);
394
395 struct pldm_get_file_table_req* req =
396 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
397 reinterpret_cast<struct pldm_get_file_table_req*>(request->payload);
398 EXPECT_EQ(transferHandle, le32toh(req->transfer_handle));
399 EXPECT_EQ(transferOpFlag, req->operation_flag);
400 EXPECT_EQ(tableType, req->table_type);
401 }
402
TEST(GetFileTable,BadEncodeRequest)403 TEST(GetFileTable, BadEncodeRequest)
404 {
405 uint32_t transferHandle = 0x0;
406 uint8_t transferOpFlag = 0x01;
407 uint8_t tableType = PLDM_FILE_ATTRIBUTE_TABLE;
408
409 auto rc = encode_get_file_table_req(0, transferHandle, transferOpFlag,
410 tableType, nullptr);
411
412 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
413 }
414
TEST(GetFileTable,GoodDecodeResponse)415 TEST(GetFileTable, GoodDecodeResponse)
416 {
417 uint32_t nextTransferHandle = 32;
418 uint8_t completionCode = PLDM_SUCCESS;
419 uint8_t transferFlag = PLDM_START_AND_END;
420 std::vector<uint8_t> fileTableData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
421
422 std::vector<uint8_t> responseMsg(
423 hdrSize + PLDM_GET_FILE_TABLE_MIN_RESP_BYTES + fileTableData.size());
424
425 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
426 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
427 size_t payload_length = responseMsg.size() - hdrSize;
428
429 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
430 auto resp = reinterpret_cast<struct pldm_get_file_table_resp*>(
431 responsePtr->payload);
432
433 resp->completion_code = completionCode;
434 resp->next_transfer_handle = htole32(nextTransferHandle);
435 resp->transfer_flag = transferFlag;
436 memcpy(resp->table_data, fileTableData.data(), fileTableData.size());
437
438 uint8_t retCompletionCode;
439 uint32_t retNextTransferHandle;
440 uint8_t retTransferFlag;
441 std::vector<uint8_t> retFileTableData(9, 0);
442 size_t retFileTableDataLength = 0;
443
444 auto rc = decode_get_file_table_resp(
445 responsePtr, payload_length, &retCompletionCode, &retNextTransferHandle,
446 &retTransferFlag, retFileTableData.data(), &retFileTableDataLength);
447
448 ASSERT_EQ(rc, PLDM_SUCCESS);
449 ASSERT_EQ(completionCode, retCompletionCode);
450 ASSERT_EQ(nextTransferHandle, retNextTransferHandle);
451 ASSERT_EQ(transferFlag, retTransferFlag);
452 ASSERT_EQ(0, memcmp(fileTableData.data(), resp->table_data,
453 retFileTableDataLength));
454 ASSERT_EQ(fileTableData.size(), retFileTableDataLength);
455 }
456
TEST(GetFileTable,BadDecodeResponse)457 TEST(GetFileTable, BadDecodeResponse)
458 {
459 uint32_t nextTransferHandle = 32;
460 uint8_t completionCode = PLDM_SUCCESS;
461 uint8_t transferFlag = PLDM_START_AND_END;
462 std::vector<uint8_t> fileTableData(9, 0);
463 size_t file_table_data_length = 0;
464
465 std::vector<uint8_t> responseMsg(
466 hdrSize + PLDM_GET_FILE_TABLE_MIN_RESP_BYTES + fileTableData.size());
467
468 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
469 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
470
471 auto rc = decode_get_file_table_resp(
472 nullptr, 0, &completionCode, &nextTransferHandle, &transferFlag,
473 fileTableData.data(), &file_table_data_length);
474
475 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
476
477 rc = decode_get_file_table_resp(
478 responsePtr, 0, &completionCode, &nextTransferHandle, &transferFlag,
479 fileTableData.data(), &file_table_data_length);
480
481 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
482 }
483
TEST(ReadFile,testGoodDecodeRequest)484 TEST(ReadFile, testGoodDecodeRequest)
485 {
486 std::array<uint8_t, PLDM_READ_FILE_REQ_BYTES + sizeof(pldm_msg_hdr)>
487 requestMsg{};
488
489 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
490 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
491 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
492 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
493 auto request = reinterpret_cast<pldm_read_file_req*>(requestPtr->payload);
494
495 // Random value for fileHandle, offset and length
496 uint32_t fileHandle = 0x12345678;
497 uint32_t offset = 0x87654321;
498 uint32_t length = 0x13245768;
499
500 request->file_handle = htole32(fileHandle);
501 request->offset = htole32(offset);
502 request->length = htole32(length);
503
504 uint32_t retFileHandle = 0;
505 uint32_t retOffset = 0;
506 uint32_t retLength = 0;
507
508 // Invoke decode the read file request
509 auto rc = decode_read_file_req(requestPtr, payload_length, &retFileHandle,
510 &retOffset, &retLength);
511
512 ASSERT_EQ(rc, PLDM_SUCCESS);
513 ASSERT_EQ(fileHandle, retFileHandle);
514 ASSERT_EQ(offset, retOffset);
515 ASSERT_EQ(length, retLength);
516 }
517
TEST(WriteFile,testGoodDecodeRequest)518 TEST(WriteFile, testGoodDecodeRequest)
519 {
520 // Random value for fileHandle, offset, length and file data
521 uint32_t fileHandle = 0x12345678;
522 uint32_t offset = 0x87654321;
523 uint32_t length = 0x467;
524
525 std::vector<uint8_t> requestMsg(PLDM_WRITE_FILE_REQ_BYTES +
526 sizeof(pldm_msg_hdr) + length);
527 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
528 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
529 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
530 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
531 auto request = reinterpret_cast<pldm_write_file_req*>(requestPtr->payload);
532
533 size_t fileDataOffset =
534 sizeof(fileHandle) + sizeof(offset) + sizeof(length);
535
536 request->file_handle = htole32(fileHandle);
537 request->offset = htole32(offset);
538 request->length = htole32(length);
539
540 uint32_t retFileHandle = 0;
541 uint32_t retOffset = 0;
542 uint32_t retLength = 0;
543 size_t retFileDataOffset = 0;
544
545 // Invoke decode the write file request
546 auto rc = decode_write_file_req(requestPtr, payload_length, &retFileHandle,
547 &retOffset, &retLength, &retFileDataOffset);
548
549 ASSERT_EQ(rc, PLDM_SUCCESS);
550 ASSERT_EQ(fileHandle, retFileHandle);
551 ASSERT_EQ(offset, retOffset);
552 ASSERT_EQ(length, retLength);
553 ASSERT_EQ(fileDataOffset, retFileDataOffset);
554 }
555
TEST(ReadFile,testGoodDecodeResponse)556 TEST(ReadFile, testGoodDecodeResponse)
557 {
558 // Random value for length
559 uint32_t length = 0x10;
560 uint8_t completionCode = PLDM_SUCCESS;
561
562 std::vector<uint8_t> responseMsg(PLDM_READ_FILE_RESP_BYTES +
563 sizeof(pldm_msg_hdr) + length);
564 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
565 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
566 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
567 auto response =
568 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
569 reinterpret_cast<pldm_read_file_resp*>(responsePtr->payload);
570
571 response->completion_code = completionCode;
572 response->length = htole32(length);
573
574 size_t fileDataOffset = sizeof(completionCode) + sizeof(length);
575
576 uint32_t retLength = 0;
577 uint8_t retCompletionCode = 0;
578 size_t retFileDataOffset = 0;
579
580 // Invoke decode the read file response
581 auto rc =
582 decode_read_file_resp(responsePtr, payload_length, &retCompletionCode,
583 &retLength, &retFileDataOffset);
584
585 ASSERT_EQ(rc, PLDM_SUCCESS);
586 ASSERT_EQ(completionCode, retCompletionCode);
587 ASSERT_EQ(length, retLength);
588 ASSERT_EQ(fileDataOffset, retFileDataOffset);
589 }
590
TEST(WriteFile,testGoodDecodeResponse)591 TEST(WriteFile, testGoodDecodeResponse)
592 {
593 std::array<uint8_t, PLDM_WRITE_FILE_RESP_BYTES + sizeof(pldm_msg_hdr)>
594 responseMsg{};
595 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
596 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
597 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
598 auto response =
599 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
600 reinterpret_cast<pldm_write_file_resp*>(responsePtr->payload);
601
602 uint8_t completionCode = PLDM_SUCCESS;
603 uint32_t length = 0x4678;
604
605 response->completion_code = completionCode;
606 response->length = htole32(length);
607
608 uint32_t retLength = 0;
609 uint8_t retCompletionCode = 0;
610
611 // Invoke decode the write file response
612 auto rc = decode_write_file_resp(responsePtr, payload_length,
613 &retCompletionCode, &retLength);
614
615 ASSERT_EQ(rc, PLDM_SUCCESS);
616 ASSERT_EQ(completionCode, retCompletionCode);
617 ASSERT_EQ(length, retLength);
618 }
619
TEST(ReadWriteFile,testBadDecodeResponse)620 TEST(ReadWriteFile, testBadDecodeResponse)
621 {
622 uint32_t length = 0;
623 uint8_t completionCode = 0;
624 size_t fileDataOffset = 0;
625
626 // Bad decode response for read file
627 std::vector<uint8_t> responseMsg(PLDM_READ_FILE_RESP_BYTES +
628 sizeof(pldm_msg_hdr) + length);
629 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
630 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
631
632 // Request payload message is missing
633 auto rc = decode_read_file_resp(NULL, 0, &completionCode, &length,
634 &fileDataOffset);
635 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
636
637 // Payload length is invalid
638 rc = decode_read_file_resp(responsePtr, 0, &completionCode, &length,
639 &fileDataOffset);
640 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
641
642 // Bad decode response for write file
643 std::array<uint8_t, PLDM_WRITE_FILE_RESP_BYTES + sizeof(pldm_msg_hdr)>
644 responseMsgWr{};
645 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
646 auto responseWr = reinterpret_cast<pldm_msg*>(responseMsgWr.data());
647
648 // Request payload message is missing
649 rc = decode_write_file_resp(NULL, 0, &completionCode, &length);
650 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
651
652 // Payload length is invalid
653 rc = decode_write_file_resp(responseWr, 0, &completionCode, &length);
654 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
655 }
656
TEST(ReadWriteFile,testBadDecodeRequest)657 TEST(ReadWriteFile, testBadDecodeRequest)
658 {
659 uint32_t fileHandle = 0;
660 uint32_t offset = 0;
661 uint32_t length = 0;
662
663 // Bad decode request for read file
664 std::array<uint8_t, PLDM_READ_FILE_REQ_BYTES + sizeof(pldm_msg_hdr)>
665 requestMsg{};
666 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
667 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
668
669 // Request payload message is missing
670 auto rc = decode_read_file_req(NULL, 0, &fileHandle, &offset, &length);
671 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
672
673 // Payload length is invalid
674 rc = decode_read_file_req(requestPtr, 0, &fileHandle, &offset, &length);
675 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
676
677 // Bad decode request for write file
678 size_t fileDataOffset = 0;
679 std::array<uint8_t, PLDM_WRITE_FILE_REQ_BYTES> requestMsgWr{};
680 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
681 auto requestWr = reinterpret_cast<pldm_msg*>(requestMsgWr.data());
682
683 // Request payload message is missing
684 rc = decode_write_file_req(NULL, 0, &fileHandle, &offset, &length,
685 &fileDataOffset);
686 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
687
688 // Payload length is invalid
689 rc = decode_write_file_req(requestWr, 0, &fileHandle, &offset, &length,
690 &fileDataOffset);
691 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
692 }
693
TEST(ReadFile,testGoodEncodeResponse)694 TEST(ReadFile, testGoodEncodeResponse)
695 {
696 // Good encode response for read file
697 uint32_t length = 0x4;
698
699 std::vector<uint8_t> responseMsg(PLDM_READ_FILE_RESP_BYTES +
700 sizeof(pldm_msg_hdr) + length);
701 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
702 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
703 auto response =
704 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
705 reinterpret_cast<pldm_read_file_resp*>(responsePtr->payload);
706
707 // ReadFile
708 auto rc = encode_read_file_resp(0, PLDM_SUCCESS, length, responsePtr);
709
710 ASSERT_EQ(rc, PLDM_SUCCESS);
711 ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
712 ASSERT_EQ(responsePtr->hdr.instance_id, 0);
713 ASSERT_EQ(responsePtr->hdr.type, PLDM_OEM);
714 ASSERT_EQ(responsePtr->hdr.command, PLDM_READ_FILE);
715 ASSERT_EQ(response->completion_code, PLDM_SUCCESS);
716 ASSERT_EQ(le32toh(response->length), length);
717 }
718
TEST(WriteFile,testGoodEncodeResponse)719 TEST(WriteFile, testGoodEncodeResponse)
720 {
721 uint32_t length = 0x467;
722
723 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_WRITE_FILE_RESP_BYTES>
724 responseMsg{};
725
726 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
727 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
728 auto response =
729 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
730 reinterpret_cast<pldm_write_file_resp*>(responsePtr->payload);
731
732 // WriteFile
733 auto rc = encode_write_file_resp(0, PLDM_SUCCESS, length, responsePtr);
734 ASSERT_EQ(rc, PLDM_SUCCESS);
735 ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
736 ASSERT_EQ(responsePtr->hdr.instance_id, 0);
737 ASSERT_EQ(responsePtr->hdr.type, PLDM_OEM);
738 ASSERT_EQ(responsePtr->hdr.command, PLDM_WRITE_FILE);
739 ASSERT_EQ(response->completion_code, PLDM_SUCCESS);
740 ASSERT_EQ(le32toh(response->length), length);
741 }
742
TEST(ReadFile,testGoodEncodeRequest)743 TEST(ReadFile, testGoodEncodeRequest)
744 {
745 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_REQ_BYTES>
746 requestMsg{};
747
748 uint32_t fileHandle = 0x12345678;
749 uint32_t offset = 0x87654321;
750 uint32_t length = 0x13245768;
751 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
752 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
753 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
754 auto request = reinterpret_cast<pldm_read_file_req*>(requestPtr->payload);
755
756 // ReadFile
757 auto rc = encode_read_file_req(0, fileHandle, offset, length, requestPtr);
758
759 ASSERT_EQ(rc, PLDM_SUCCESS);
760 ASSERT_EQ(requestPtr->hdr.request, PLDM_REQUEST);
761 ASSERT_EQ(requestPtr->hdr.instance_id, 0);
762 ASSERT_EQ(requestPtr->hdr.type, PLDM_OEM);
763 ASSERT_EQ(requestPtr->hdr.command, PLDM_READ_FILE);
764 ASSERT_EQ(le32toh(request->file_handle), fileHandle);
765 ASSERT_EQ(le32toh(request->offset), offset);
766 ASSERT_EQ(le32toh(request->length), length);
767 }
768
TEST(WriteFile,testGoodEncodeRequest)769 TEST(WriteFile, testGoodEncodeRequest)
770 {
771 uint32_t fileHandle = 0x12345678;
772 uint32_t offset = 0x87654321;
773 uint32_t length = 0x456;
774
775 std::vector<uint8_t> requestMsg(PLDM_WRITE_FILE_REQ_BYTES +
776 sizeof(pldm_msg_hdr) + length);
777 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
778 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
779 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
780 auto request = reinterpret_cast<pldm_write_file_req*>(requestPtr->payload);
781
782 // WriteFile
783 auto rc = encode_write_file_req(0, fileHandle, offset, length, requestPtr);
784
785 ASSERT_EQ(rc, PLDM_SUCCESS);
786 ASSERT_EQ(requestPtr->hdr.request, PLDM_REQUEST);
787 ASSERT_EQ(requestPtr->hdr.instance_id, 0);
788 ASSERT_EQ(requestPtr->hdr.type, PLDM_OEM);
789 ASSERT_EQ(requestPtr->hdr.command, PLDM_WRITE_FILE);
790 ASSERT_EQ(le32toh(request->file_handle), fileHandle);
791 ASSERT_EQ(le32toh(request->offset), offset);
792 ASSERT_EQ(le32toh(request->length), length);
793 }
794
TEST(ReadWriteFile,testBadEncodeRequest)795 TEST(ReadWriteFile, testBadEncodeRequest)
796 {
797 // Bad encode request for read file
798 uint32_t fileHandle = 0;
799 uint32_t offset = 0;
800 uint32_t length = 0;
801
802 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_REQ_BYTES>
803 requestMsg{};
804 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
805 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
806
807 // ReadFile check invalid file length
808 auto rc = encode_read_file_req(0, fileHandle, offset, length, requestPtr);
809
810 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
811
812 // Bad encode request for write file
813 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_WRITE_FILE_REQ_BYTES>
814 requestMsgWr{};
815 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
816 auto requestWr = reinterpret_cast<pldm_msg*>(requestMsgWr.data());
817
818 // WriteFile check for invalid file length
819 rc = encode_write_file_req(0, fileHandle, offset, length, requestWr);
820
821 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
822 }
823
TEST(ReadWriteFile,testBadEncodeResponse)824 TEST(ReadWriteFile, testBadEncodeResponse)
825 {
826 // Bad encode response for read file
827 uint32_t length = 0;
828
829 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_RESP_BYTES>
830 responseMsg{};
831 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
832 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
833
834 // ReadFile
835 auto rc = encode_read_file_resp(0, PLDM_ERROR, length, responsePtr);
836
837 ASSERT_EQ(rc, PLDM_SUCCESS);
838 ASSERT_EQ(responsePtr->hdr.request, PLDM_RESPONSE);
839 ASSERT_EQ(responsePtr->hdr.instance_id, 0);
840 ASSERT_EQ(responsePtr->hdr.type, PLDM_OEM);
841 ASSERT_EQ(responsePtr->hdr.command, PLDM_READ_FILE);
842 ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR);
843
844 // Bad encode response for write file
845 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_WRITE_FILE_RESP_BYTES>
846 responseMsgWr{};
847 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
848 auto responseWr = reinterpret_cast<pldm_msg*>(responseMsgWr.data());
849
850 // WriteFile
851 rc = encode_write_file_resp(0, PLDM_ERROR, length, responseWr);
852
853 ASSERT_EQ(rc, PLDM_SUCCESS);
854 ASSERT_EQ(responseWr->hdr.request, PLDM_RESPONSE);
855 ASSERT_EQ(responseWr->hdr.instance_id, 0);
856 ASSERT_EQ(responseWr->hdr.type, PLDM_OEM);
857 ASSERT_EQ(responseWr->hdr.command, PLDM_WRITE_FILE);
858 ASSERT_EQ(responseWr->payload[0], PLDM_ERROR);
859 }
860
TEST(ReadWriteFileByTypeMemory,testGoodDecodeRequest)861 TEST(ReadWriteFileByTypeMemory, testGoodDecodeRequest)
862 {
863 std::array<uint8_t,
864 PLDM_RW_FILE_BY_TYPE_MEM_REQ_BYTES + sizeof(pldm_msg_hdr)>
865 requestMsg{};
866
867 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
868 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
869 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
870 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
871 auto request = reinterpret_cast<pldm_read_write_file_by_type_memory_req*>(
872 requestPtr->payload);
873
874 // Random value for fileHandle, offset and length
875 uint16_t fileType = 0;
876 uint32_t fileHandle = 0x12345678;
877 uint32_t offset = 0x87654321;
878 uint32_t length = 0x13245768;
879 uint64_t address = 0x124356879acbd456;
880
881 request->file_type = htole16(fileType);
882 request->file_handle = htole32(fileHandle);
883 request->offset = htole32(offset);
884 request->length = htole32(length);
885 request->address = htole64(address);
886
887 uint16_t retFileType = 0x1;
888 uint32_t retFileHandle = 0;
889 uint32_t retOffset = 0;
890 uint32_t retLength = 0;
891 uint64_t retAddress = 0;
892
893 // Invoke decode the read file request
894 auto rc = decode_rw_file_by_type_memory_req(
895 requestPtr, payload_length, &retFileType, &retFileHandle, &retOffset,
896 &retLength, &retAddress);
897
898 ASSERT_EQ(rc, PLDM_SUCCESS);
899 ASSERT_EQ(fileType, retFileType);
900 ASSERT_EQ(fileHandle, retFileHandle);
901 ASSERT_EQ(offset, retOffset);
902 ASSERT_EQ(length, retLength);
903 ASSERT_EQ(address, retAddress);
904 }
905
TEST(ReadWriteFileByTypeMemory,testGoodDecodeResponse)906 TEST(ReadWriteFileByTypeMemory, testGoodDecodeResponse)
907 {
908 std::array<uint8_t,
909 PLDM_RW_FILE_BY_TYPE_MEM_RESP_BYTES + sizeof(pldm_msg_hdr)>
910 responseMsg{};
911
912 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
913 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
914 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
915 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
916 auto response = reinterpret_cast<pldm_read_write_file_by_type_memory_resp*>(
917 responsePtr->payload);
918
919 // Random value for completion code and length
920 uint8_t completionCode = 0x0;
921 uint32_t length = 0x13245768;
922
923 response->completion_code = completionCode;
924 response->length = htole32(length);
925
926 uint8_t retCompletionCode = 0x1;
927 uint32_t retLength = 0;
928
929 // Invoke decode the read/write file response
930 auto rc = decode_rw_file_by_type_memory_resp(
931 responsePtr, payload_length, &retCompletionCode, &retLength);
932
933 ASSERT_EQ(rc, PLDM_SUCCESS);
934 ASSERT_EQ(completionCode, retCompletionCode);
935 ASSERT_EQ(length, retLength);
936 }
937
TEST(ReadWriteFileByTypeMemory,testBadDecodeRequest)938 TEST(ReadWriteFileByTypeMemory, testBadDecodeRequest)
939 {
940 uint16_t fileType = 0;
941 uint32_t fileHandle = 0;
942 uint32_t offset = 0;
943 uint32_t length = 0;
944 uint64_t address = 0;
945
946 // Request payload message is missing
947 auto rc = decode_rw_file_by_type_memory_req(NULL, 0, &fileType, &fileHandle,
948 &offset, &length, &address);
949 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
950
951 std::array<uint8_t,
952 PLDM_RW_FILE_BY_TYPE_MEM_REQ_BYTES + sizeof(pldm_msg_hdr)>
953 requestMsg{};
954
955 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
956 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
957
958 // Address is NULL
959 rc = decode_rw_file_by_type_memory_req(
960 requestPtr, requestMsg.size() - hdrSize, &fileType, &fileHandle,
961 &offset, &length, NULL);
962 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
963
964 // Payload length is invalid
965 rc = decode_rw_file_by_type_memory_req(
966 requestPtr, 0, &fileType, &fileHandle, &offset, &length, &address);
967 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
968 }
969
TEST(ReadWriteFileByTypeMemory,testBadDecodeResponse)970 TEST(ReadWriteFileByTypeMemory, testBadDecodeResponse)
971 {
972 uint32_t length = 0;
973 uint8_t completionCode = 0;
974
975 // Request payload message is missing
976 auto rc =
977 decode_rw_file_by_type_memory_resp(NULL, 0, &completionCode, &length);
978 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
979
980 std::array<uint8_t,
981 PLDM_RW_FILE_BY_TYPE_MEM_RESP_BYTES + sizeof(pldm_msg_hdr)>
982 responseMsg{};
983
984 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
985 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
986
987 // Length is NULL
988 rc = decode_rw_file_by_type_memory_resp(
989 responsePtr, responseMsg.size() - hdrSize, &completionCode, NULL);
990 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
991
992 // Payload length is invalid
993 rc = decode_rw_file_by_type_memory_resp(responsePtr, 0, &completionCode,
994 &length);
995 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
996 }
997
TEST(ReadWriteFileByTypeMemory,testGoodEncodeRequest)998 TEST(ReadWriteFileByTypeMemory, testGoodEncodeRequest)
999 {
1000 std::array<uint8_t,
1001 sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_MEM_REQ_BYTES>
1002 requestMsg{};
1003
1004 uint16_t fileType = 0;
1005 uint32_t fileHandle = 0x12345678;
1006 uint32_t offset = 0x87654321;
1007 uint32_t length = 0x13245768;
1008 uint64_t address = 0x124356879acbde0f;
1009 uint16_t fileTypeLe = htole16(fileType);
1010 uint32_t fileHandleLe = htole32(fileHandle);
1011 uint32_t offsetLe = htole32(offset);
1012 uint32_t lengthLe = htole32(length);
1013 uint64_t addressLe = htole64(address);
1014
1015 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1016 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1017
1018 auto rc = encode_rw_file_by_type_memory_req(
1019 0, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, fileType, fileHandle, offset,
1020 length, address, request);
1021
1022 ASSERT_EQ(rc, PLDM_SUCCESS);
1023 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
1024 ASSERT_EQ(request->hdr.instance_id, 0);
1025 ASSERT_EQ(request->hdr.type, PLDM_OEM);
1026 ASSERT_EQ(request->hdr.command, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY);
1027
1028 ASSERT_EQ(0, memcmp(request->payload, &fileTypeLe, sizeof(fileTypeLe)));
1029 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe), &fileHandleLe,
1030 sizeof(fileHandleLe)));
1031
1032 ASSERT_EQ(
1033 0, memcmp(request->payload + sizeof(fileTypeLe) + sizeof(fileHandleLe),
1034 &offsetLe, sizeof(offsetLe)));
1035 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1036 sizeof(fileHandleLe) + sizeof(offsetLe),
1037 &lengthLe, sizeof(lengthLe)));
1038 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1039 sizeof(fileHandleLe) + sizeof(offsetLe) +
1040 sizeof(lengthLe),
1041 &addressLe, sizeof(addressLe)));
1042 }
1043
TEST(ReadWriteFileByTypeMemory,testGoodEncodeResponse)1044 TEST(ReadWriteFileByTypeMemory, testGoodEncodeResponse)
1045 {
1046 std::array<uint8_t,
1047 sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_MEM_RESP_BYTES>
1048 responseMsg{};
1049
1050 uint32_t length = 0x13245768;
1051 uint32_t lengthLe = htole32(length);
1052 uint8_t completionCode = 0x0;
1053
1054 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1055 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1056
1057 auto rc = encode_rw_file_by_type_memory_resp(
1058 0, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, completionCode, length,
1059 response);
1060
1061 ASSERT_EQ(rc, PLDM_SUCCESS);
1062 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1063 ASSERT_EQ(response->hdr.instance_id, 0);
1064 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1065 ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY);
1066
1067 ASSERT_EQ(
1068 0, memcmp(response->payload, &completionCode, sizeof(completionCode)));
1069 ASSERT_EQ(0, memcmp(response->payload + sizeof(completionCode), &lengthLe,
1070 sizeof(lengthLe)));
1071 }
1072
TEST(ReadWriteFileByTypeMemory,testBadEncodeResponse)1073 TEST(ReadWriteFileByTypeMemory, testBadEncodeResponse)
1074 {
1075 std::array<uint8_t,
1076 sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_MEM_RESP_BYTES>
1077 responseMsg{};
1078 uint32_t length = 0;
1079 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1080 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1081
1082 // completion code is PLDM_ERROR
1083 auto rc = encode_rw_file_by_type_memory_resp(
1084 0, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, PLDM_ERROR, length, response);
1085
1086 ASSERT_EQ(rc, PLDM_SUCCESS);
1087 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1088 ASSERT_EQ(response->hdr.instance_id, 0);
1089 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1090 ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY);
1091 ASSERT_EQ(response->payload[0], PLDM_ERROR);
1092
1093 // response is NULL pointer
1094 rc = encode_rw_file_by_type_memory_resp(
1095 0, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, PLDM_SUCCESS, length, NULL);
1096
1097 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1098 }
1099
TEST(ReadWriteFileByTypeMemory,testBadEncodeRequest)1100 TEST(ReadWriteFileByTypeMemory, testBadEncodeRequest)
1101 {
1102 uint8_t fileType = 0;
1103 uint32_t fileHandle = 0;
1104 uint32_t offset = 0;
1105 uint32_t length = 0;
1106 uint64_t address = 0;
1107
1108 // request is NULL pointer
1109 auto rc = encode_rw_file_by_type_memory_req(
1110 0, PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, fileType, fileHandle, offset,
1111 length, address, NULL);
1112
1113 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1114 }
1115
TEST(NewFile,testGoodDecodeRequest)1116 TEST(NewFile, testGoodDecodeRequest)
1117 {
1118 std::array<uint8_t, PLDM_NEW_FILE_REQ_BYTES + sizeof(pldm_msg_hdr)>
1119 requestMsg{};
1120
1121 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1122 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1123 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
1124 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1125 auto request = reinterpret_cast<pldm_new_file_req*>(requestPtr->payload);
1126
1127 // Random value for fileHandle and length
1128 uint16_t fileType = 0xff;
1129 uint32_t fileHandle = 0x12345678;
1130 uint64_t length = 0x13245768;
1131
1132 request->file_type = htole16(fileType);
1133 request->file_handle = htole32(fileHandle);
1134 request->length = htole64(length);
1135
1136 uint16_t retFileType = 0xff;
1137 uint32_t retFileHandle = 0;
1138 uint64_t retLength = 0;
1139
1140 // Invoke decode the read file request
1141 auto rc = decode_new_file_req(requestPtr, payload_length, &retFileType,
1142 &retFileHandle, &retLength);
1143
1144 ASSERT_EQ(rc, PLDM_SUCCESS);
1145 ASSERT_EQ(fileType, retFileType);
1146 ASSERT_EQ(fileHandle, retFileHandle);
1147 ASSERT_EQ(length, retLength);
1148 }
1149
TEST(NewFile,testGoodDecodeResponse)1150 TEST(NewFile, testGoodDecodeResponse)
1151 {
1152 std::array<uint8_t, PLDM_NEW_FILE_RESP_BYTES + sizeof(pldm_msg_hdr)>
1153 responseMsg{};
1154
1155 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1156 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1157 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
1158 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1159 auto response = reinterpret_cast<pldm_new_file_resp*>(responsePtr->payload);
1160
1161 // Random value for completion code
1162 uint8_t completionCode = 0x0;
1163
1164 response->completion_code = completionCode;
1165
1166 uint8_t retCompletionCode = PLDM_SUCCESS;
1167
1168 // Invoke decode the read/write file response
1169 auto rc =
1170 decode_new_file_resp(responsePtr, payload_length, &retCompletionCode);
1171
1172 ASSERT_EQ(rc, PLDM_SUCCESS);
1173 ASSERT_EQ(completionCode, retCompletionCode);
1174 }
1175
TEST(NewFile,testBadDecodeRequest)1176 TEST(NewFile, testBadDecodeRequest)
1177 {
1178 uint16_t fileType = 0;
1179 uint32_t fileHandle = 0;
1180 uint64_t length = 0;
1181
1182 // Request payload message is missing
1183 auto rc = decode_new_file_req(NULL, 0, &fileType, &fileHandle, &length);
1184
1185 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1186
1187 std::array<uint8_t, PLDM_NEW_FILE_REQ_BYTES + sizeof(pldm_msg_hdr)>
1188 requestMsg{};
1189
1190 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1191 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1192
1193 // Payload length is invalid
1194 rc = decode_new_file_req(requestPtr, 0, &fileType, &fileHandle, &length);
1195 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1196 }
1197
TEST(NewFile,testBadDecodeResponse)1198 TEST(NewFile, testBadDecodeResponse)
1199 {
1200 uint8_t completionCode = 0;
1201
1202 // Request payload message is missing
1203 auto rc = decode_new_file_resp(NULL, 0, &completionCode);
1204 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1205
1206 std::array<uint8_t, PLDM_NEW_FILE_RESP_BYTES + sizeof(pldm_msg_hdr)>
1207 responseMsg{};
1208
1209 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1210 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1211
1212 // Payload length is invalid
1213 rc = decode_new_file_resp(responsePtr, 0, &completionCode);
1214 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1215 }
1216
TEST(NewFile,testGoodEncodeRequest)1217 TEST(NewFile, testGoodEncodeRequest)
1218 {
1219 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_NEW_FILE_REQ_BYTES>
1220 requestMsg{};
1221
1222 uint16_t fileType = 0xff;
1223 uint32_t fileHandle = 0x12345678;
1224 uint32_t length = 0x13245768;
1225 uint16_t fileTypeLe = htole16(fileType);
1226 uint32_t fileHandleLe = htole32(fileHandle);
1227 uint32_t lengthLe = htole32(length);
1228
1229 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1230 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1231
1232 auto rc = encode_new_file_req(0, fileType, fileHandle, length, request);
1233
1234 ASSERT_EQ(rc, PLDM_SUCCESS);
1235 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
1236 ASSERT_EQ(request->hdr.instance_id, 0);
1237 ASSERT_EQ(request->hdr.type, PLDM_OEM);
1238 ASSERT_EQ(request->hdr.command, PLDM_NEW_FILE_AVAILABLE);
1239 ASSERT_EQ(0, memcmp(request->payload, &fileTypeLe, sizeof(fileTypeLe)));
1240 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe), &fileHandleLe,
1241 sizeof(fileHandleLe)));
1242 ASSERT_EQ(
1243 0, memcmp(request->payload + sizeof(fileTypeLe) + sizeof(fileHandleLe),
1244 &lengthLe, sizeof(lengthLe)));
1245 }
1246
TEST(NewFile,testGoodEncodeResponse)1247 TEST(NewFile, testGoodEncodeResponse)
1248 {
1249 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_NEW_FILE_RESP_BYTES>
1250 responseMsg{};
1251
1252 uint8_t completionCode = 0x0;
1253
1254 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1255 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1256
1257 auto rc = encode_new_file_resp(0, completionCode, response);
1258
1259 ASSERT_EQ(rc, PLDM_SUCCESS);
1260 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1261 ASSERT_EQ(response->hdr.instance_id, 0);
1262 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1263 ASSERT_EQ(response->hdr.command, PLDM_NEW_FILE_AVAILABLE);
1264 ASSERT_EQ(
1265 0, memcmp(response->payload, &completionCode, sizeof(completionCode)));
1266 }
1267
TEST(NewFile,testBadEncodeResponse)1268 TEST(NewFile, testBadEncodeResponse)
1269 {
1270 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_NEW_FILE_RESP_BYTES>
1271 responseMsg{};
1272 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1273 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1274
1275 // completion code is PLDM_ERROR
1276 auto rc = encode_new_file_resp(0, PLDM_ERROR, response);
1277
1278 ASSERT_EQ(rc, PLDM_SUCCESS);
1279 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1280 ASSERT_EQ(response->hdr.instance_id, 0);
1281 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1282 ASSERT_EQ(response->hdr.command, PLDM_NEW_FILE_AVAILABLE);
1283 ASSERT_EQ(response->payload[0], PLDM_ERROR);
1284
1285 // response is NULL pointer
1286 rc = encode_new_file_resp(0, PLDM_SUCCESS, NULL);
1287
1288 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1289 }
1290
TEST(NewFile,testBadEncodeRequest)1291 TEST(NewFile, testBadEncodeRequest)
1292 {
1293 uint8_t fileType = 0xff;
1294 uint32_t fileHandle = 0;
1295 uint32_t length = 0;
1296
1297 // request is NULL pointer
1298 auto rc = encode_new_file_req(0, fileType, fileHandle, length, NULL);
1299
1300 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1301 }
1302
TEST(ReadWriteFileByType,testGoodDecodeRequest)1303 TEST(ReadWriteFileByType, testGoodDecodeRequest)
1304 {
1305 std::array<uint8_t, PLDM_RW_FILE_BY_TYPE_REQ_BYTES + sizeof(pldm_msg_hdr)>
1306 requestMsg{};
1307
1308 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1309 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1310 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
1311 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1312 auto request = reinterpret_cast<pldm_read_write_file_by_type_req*>(
1313 requestPtr->payload);
1314
1315 // Random value for fileHandle, offset and length
1316 uint16_t fileType = 0;
1317 uint32_t fileHandle = 0x12345678;
1318 uint32_t offset = 0x87654321;
1319 uint32_t length = 0x13245768;
1320
1321 request->file_handle = htole32(fileHandle);
1322 request->offset = htole32(offset);
1323 request->length = htole32(length);
1324
1325 uint16_t retFileType = 0x1;
1326 uint32_t retFileHandle = 0;
1327 uint32_t retOffset = 0;
1328 uint32_t retLength = 0;
1329
1330 // Invoke decode the read file request
1331 auto rc =
1332 decode_rw_file_by_type_req(requestPtr, payload_length, &retFileType,
1333 &retFileHandle, &retOffset, &retLength);
1334
1335 ASSERT_EQ(rc, PLDM_SUCCESS);
1336 ASSERT_EQ(fileType, retFileType);
1337 ASSERT_EQ(fileHandle, retFileHandle);
1338 ASSERT_EQ(offset, retOffset);
1339 ASSERT_EQ(length, retLength);
1340 }
1341
TEST(ReadWriteFileByType,testGoodDecodeResponse)1342 TEST(ReadWriteFileByType, testGoodDecodeResponse)
1343 {
1344 std::array<uint8_t, PLDM_RW_FILE_BY_TYPE_RESP_BYTES + sizeof(pldm_msg_hdr)>
1345 responseMsg{};
1346
1347 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1348 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1349 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
1350 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1351 auto response = reinterpret_cast<pldm_read_write_file_by_type_resp*>(
1352 responsePtr->payload);
1353
1354 // Random value for completion code and length
1355 uint8_t completionCode = 0x0;
1356 uint32_t length = 0x13245768;
1357
1358 response->completion_code = completionCode;
1359 response->length = htole32(length);
1360
1361 uint8_t retCompletionCode = 0x1;
1362 uint32_t retLength = 0;
1363
1364 // Invoke decode the read/write file response
1365 auto rc = decode_rw_file_by_type_resp(responsePtr, payload_length,
1366 &retCompletionCode, &retLength);
1367
1368 ASSERT_EQ(rc, PLDM_SUCCESS);
1369 ASSERT_EQ(completionCode, retCompletionCode);
1370 ASSERT_EQ(length, retLength);
1371 }
1372
TEST(ReadWriteFileByType,testBadDecodeRequest)1373 TEST(ReadWriteFileByType, testBadDecodeRequest)
1374 {
1375 uint16_t fileType = 0;
1376 uint32_t fileHandle = 0;
1377 uint32_t offset = 0;
1378 uint32_t length = 0;
1379
1380 // Request payload message is missing
1381 auto rc = decode_rw_file_by_type_req(NULL, 0, &fileType, &fileHandle,
1382 &offset, &length);
1383 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1384
1385 std::array<uint8_t, PLDM_RW_FILE_BY_TYPE_REQ_BYTES + sizeof(pldm_msg_hdr)>
1386 requestMsg{};
1387
1388 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1389 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1390
1391 // Payload length is invalid
1392 rc = decode_rw_file_by_type_req(requestPtr, 0, &fileType, &fileHandle,
1393 &offset, &length);
1394 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1395 }
1396
TEST(ReadWriteFileByType,testBadDecodeResponse)1397 TEST(ReadWriteFileByType, testBadDecodeResponse)
1398 {
1399 uint32_t length = 0;
1400 uint8_t completionCode = 0;
1401
1402 // Request payload message is missing
1403 auto rc = decode_rw_file_by_type_resp(NULL, 0, &completionCode, &length);
1404 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1405
1406 std::array<uint8_t, PLDM_RW_FILE_BY_TYPE_RESP_BYTES + sizeof(pldm_msg_hdr)>
1407 responseMsg{};
1408
1409 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1410 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1411
1412 // Length is NULL
1413 rc = decode_rw_file_by_type_resp(responsePtr, responseMsg.size() - hdrSize,
1414 &completionCode, NULL);
1415 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1416
1417 // Payload length is invalid
1418 rc = decode_rw_file_by_type_resp(responsePtr, 0, &completionCode, &length);
1419 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1420 }
1421
TEST(ReadWriteFileByType,testGoodEncodeRequest)1422 TEST(ReadWriteFileByType, testGoodEncodeRequest)
1423 {
1424 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_REQ_BYTES>
1425 requestMsg{};
1426
1427 uint16_t fileType = 0;
1428 uint32_t fileHandle = 0x12345678;
1429 uint32_t offset = 0x87654321;
1430 uint32_t length = 0x13245768;
1431 uint16_t fileTypeLe = htole16(fileType);
1432 uint32_t fileHandleLe = htole32(fileHandle);
1433 uint32_t offsetLe = htole32(offset);
1434 uint32_t lengthLe = htole32(length);
1435
1436 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1437 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1438
1439 auto rc = encode_rw_file_by_type_req(0, PLDM_READ_FILE_BY_TYPE, fileType,
1440 fileHandle, offset, length, request);
1441
1442 ASSERT_EQ(rc, PLDM_SUCCESS);
1443 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
1444 ASSERT_EQ(request->hdr.instance_id, 0);
1445 ASSERT_EQ(request->hdr.type, PLDM_OEM);
1446 ASSERT_EQ(request->hdr.command, PLDM_READ_FILE_BY_TYPE);
1447
1448 ASSERT_EQ(0, memcmp(request->payload, &fileTypeLe, sizeof(fileTypeLe)));
1449 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe), &fileHandleLe,
1450 sizeof(fileHandleLe)));
1451
1452 ASSERT_EQ(
1453 0, memcmp(request->payload + sizeof(fileTypeLe) + sizeof(fileHandleLe),
1454 &offsetLe, sizeof(offsetLe)));
1455 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1456 sizeof(fileHandleLe) + sizeof(offsetLe),
1457 &lengthLe, sizeof(lengthLe)));
1458 }
1459
TEST(ReadWriteFileByType,testGoodEncodeResponse)1460 TEST(ReadWriteFileByType, testGoodEncodeResponse)
1461 {
1462 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_RESP_BYTES>
1463 responseMsg{};
1464
1465 uint32_t length = 0x13245768;
1466 uint32_t lengthLe = htole32(length);
1467 uint8_t completionCode = 0x0;
1468 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1469 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1470
1471 auto rc = encode_rw_file_by_type_resp(0, PLDM_READ_FILE_BY_TYPE,
1472 completionCode, length, response);
1473
1474 ASSERT_EQ(rc, PLDM_SUCCESS);
1475 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1476 ASSERT_EQ(response->hdr.instance_id, 0);
1477 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1478 ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_BY_TYPE);
1479
1480 ASSERT_EQ(
1481 0, memcmp(response->payload, &completionCode, sizeof(completionCode)));
1482 ASSERT_EQ(0, memcmp(response->payload + sizeof(completionCode), &lengthLe,
1483 sizeof(lengthLe)));
1484 }
1485
TEST(ReadWriteFileByType,testBadEncodeResponse)1486 TEST(ReadWriteFileByType, testBadEncodeResponse)
1487 {
1488 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_RESP_BYTES>
1489 responseMsg{};
1490 uint32_t length = 0;
1491 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1492 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1493
1494 // completion code is PLDM_ERROR
1495 auto rc = encode_rw_file_by_type_resp(0, PLDM_READ_FILE_BY_TYPE, PLDM_ERROR,
1496 length, response);
1497
1498 ASSERT_EQ(rc, PLDM_SUCCESS);
1499 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1500 ASSERT_EQ(response->hdr.instance_id, 0);
1501 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1502 ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_BY_TYPE);
1503 ASSERT_EQ(response->payload[0], PLDM_ERROR);
1504
1505 // response is NULL pointer
1506 rc = encode_rw_file_by_type_resp(0, PLDM_READ_FILE_BY_TYPE, PLDM_SUCCESS,
1507 length, NULL);
1508
1509 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1510 }
1511
TEST(ReadWriteFileByType,testBadEncodeRequest)1512 TEST(ReadWriteFileByType, testBadEncodeRequest)
1513 {
1514 uint8_t fileType = 0;
1515 uint32_t fileHandle = 0;
1516 uint32_t offset = 0;
1517 uint32_t length = 0;
1518
1519 // request is NULL pointer
1520 auto rc = encode_rw_file_by_type_req(0, PLDM_READ_FILE_BY_TYPE, fileType,
1521 fileHandle, offset, length, NULL);
1522
1523 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1524 }
1525
TEST(FileAck,testGoodDecodeRequest)1526 TEST(FileAck, testGoodDecodeRequest)
1527 {
1528 std::array<uint8_t, PLDM_FILE_ACK_REQ_BYTES + sizeof(pldm_msg_hdr)>
1529 requestMsg{};
1530
1531 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1532 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1533 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
1534 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1535 auto request = reinterpret_cast<pldm_file_ack_req*>(requestPtr->payload);
1536
1537 // Random value for fileHandle
1538 uint16_t fileType = 0xffff;
1539 uint32_t fileHandle = 0x12345678;
1540 uint8_t fileStatus = 0xff;
1541
1542 request->file_type = htole16(fileType);
1543 request->file_handle = htole32(fileHandle);
1544 request->file_status = fileStatus;
1545
1546 uint16_t retFileType = 0xff;
1547 uint32_t retFileHandle = 0;
1548 uint8_t retFileStatus = 0;
1549
1550 // Invoke decode the read file request
1551 auto rc = decode_file_ack_req(requestPtr, payload_length, &retFileType,
1552 &retFileHandle, &retFileStatus);
1553
1554 ASSERT_EQ(rc, PLDM_SUCCESS);
1555 ASSERT_EQ(fileType, retFileType);
1556 ASSERT_EQ(fileHandle, retFileHandle);
1557 ASSERT_EQ(fileStatus, retFileStatus);
1558 }
1559
TEST(FileAck,testGoodDecodeResponse)1560 TEST(FileAck, testGoodDecodeResponse)
1561 {
1562 std::array<uint8_t, PLDM_FILE_ACK_RESP_BYTES + sizeof(pldm_msg_hdr)>
1563 responseMsg{};
1564
1565 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1566 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1567 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
1568 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1569 auto response = reinterpret_cast<pldm_file_ack_resp*>(responsePtr->payload);
1570
1571 // Random value for completion code
1572 uint8_t completionCode = 0x0;
1573
1574 response->completion_code = completionCode;
1575
1576 uint8_t retCompletionCode = PLDM_SUCCESS;
1577
1578 // Invoke decode the read/write file response
1579 auto rc =
1580 decode_file_ack_resp(responsePtr, payload_length, &retCompletionCode);
1581
1582 ASSERT_EQ(rc, PLDM_SUCCESS);
1583 ASSERT_EQ(completionCode, retCompletionCode);
1584 }
1585
TEST(FileAck,testBadDecodeRequest)1586 TEST(FileAck, testBadDecodeRequest)
1587 {
1588 uint16_t fileType = 0;
1589 uint32_t fileHandle = 0;
1590 uint8_t fileStatus = 0;
1591
1592 // Request payload message is missing
1593 auto rc = decode_file_ack_req(NULL, 0, &fileType, &fileHandle, &fileStatus);
1594
1595 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1596
1597 std::array<uint8_t, PLDM_FILE_ACK_REQ_BYTES + sizeof(pldm_msg_hdr)>
1598 requestMsg{};
1599
1600 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1601 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1602
1603 // Payload length is invalid
1604 rc =
1605 decode_file_ack_req(requestPtr, 0, &fileType, &fileHandle, &fileStatus);
1606 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1607 }
1608
TEST(FileAck,testBadDecodeResponse)1609 TEST(FileAck, testBadDecodeResponse)
1610 {
1611 uint8_t completionCode = 0;
1612
1613 // Request payload message is missing
1614 auto rc = decode_file_ack_resp(NULL, 0, &completionCode);
1615 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1616
1617 std::array<uint8_t, PLDM_FILE_ACK_RESP_BYTES + sizeof(pldm_msg_hdr)>
1618 responseMsg{};
1619
1620 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1621 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1622
1623 // Payload length is invalid
1624 rc = decode_file_ack_resp(responsePtr, 0, &completionCode);
1625 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1626 }
1627
TEST(FileAck,testGoodEncodeRequest)1628 TEST(FileAck, testGoodEncodeRequest)
1629 {
1630 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_REQ_BYTES>
1631 requestMsg{};
1632
1633 uint16_t fileType = 0xffff;
1634 uint32_t fileHandle = 0x12345678;
1635 uint8_t fileStatus = 0xff;
1636 uint16_t fileTypeLe = htole16(fileType);
1637 uint32_t fileHandleLe = htole32(fileHandle);
1638
1639 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1640 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1641
1642 auto rc = encode_file_ack_req(0, fileType, fileHandle, fileStatus, request);
1643
1644 ASSERT_EQ(rc, PLDM_SUCCESS);
1645 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
1646 ASSERT_EQ(request->hdr.instance_id, 0);
1647 ASSERT_EQ(request->hdr.type, PLDM_OEM);
1648 ASSERT_EQ(request->hdr.command, PLDM_FILE_ACK);
1649 ASSERT_EQ(0, memcmp(request->payload, &fileTypeLe, sizeof(fileTypeLe)));
1650 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe), &fileHandleLe,
1651 sizeof(fileHandleLe)));
1652 }
1653
TEST(FileAck,testGoodEncodeResponse)1654 TEST(FileAck, testGoodEncodeResponse)
1655 {
1656 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_RESP_BYTES>
1657 responseMsg{};
1658
1659 uint8_t completionCode = 0x0;
1660
1661 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1662 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1663
1664 auto rc = encode_file_ack_resp(0, completionCode, response);
1665
1666 ASSERT_EQ(rc, PLDM_SUCCESS);
1667 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1668 ASSERT_EQ(response->hdr.instance_id, 0);
1669 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1670 ASSERT_EQ(response->hdr.command, PLDM_FILE_ACK);
1671 ASSERT_EQ(
1672 0, memcmp(response->payload, &completionCode, sizeof(completionCode)));
1673 }
1674
TEST(FileAck,testBadEncodeResponse)1675 TEST(FileAck, testBadEncodeResponse)
1676 {
1677 std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_RESP_BYTES>
1678 responseMsg{};
1679 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1680 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1681
1682 // completion code is PLDM_ERROR
1683 auto rc = encode_file_ack_resp(0, PLDM_ERROR, response);
1684
1685 ASSERT_EQ(rc, PLDM_SUCCESS);
1686 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1687 ASSERT_EQ(response->hdr.instance_id, 0);
1688 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1689 ASSERT_EQ(response->hdr.command, PLDM_FILE_ACK);
1690 ASSERT_EQ(response->payload[0], PLDM_ERROR);
1691
1692 // response is NULL pointer
1693 rc = encode_file_ack_resp(0, PLDM_SUCCESS, NULL);
1694
1695 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1696 }
1697
TEST(FileAck,testBadEncodeRequest)1698 TEST(FileAck, testBadEncodeRequest)
1699 {
1700 uint8_t fileType = 0xff;
1701 uint32_t fileHandle = 0;
1702 uint8_t fileStatus = 0;
1703
1704 // request is NULL pointer
1705 auto rc = encode_file_ack_req(0, fileType, fileHandle, fileStatus, nullptr);
1706
1707 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1708 }
1709
TEST(FileAckWithMetadata,testGoodEncodeResponse)1710 TEST(FileAckWithMetadata, testGoodEncodeResponse)
1711 {
1712 std::array<uint8_t,
1713 sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_WITH_META_DATA_RESP_BYTES>
1714 responseMsg{};
1715
1716 uint8_t completionCode = 0x0;
1717
1718 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1719 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1720
1721 auto rc = encode_file_ack_with_meta_data_resp(0, completionCode, response);
1722
1723 ASSERT_EQ(rc, PLDM_SUCCESS);
1724 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1725 ASSERT_EQ(response->hdr.instance_id, 0);
1726 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1727 ASSERT_EQ(response->hdr.command, PLDM_FILE_ACK_WITH_META_DATA);
1728 ASSERT_EQ(
1729 0, memcmp(response->payload, &completionCode, sizeof(completionCode)));
1730 }
1731
TEST(FileAckWithMetadata,testBadEncodeResponse)1732 TEST(FileAckWithMetadata, testBadEncodeResponse)
1733 {
1734 std::array<uint8_t,
1735 sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_WITH_META_DATA_RESP_BYTES>
1736 responseMsg{};
1737 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1738 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1739
1740 // completion code is PLDM_ERROR
1741 auto rc = encode_file_ack_with_meta_data_resp(0, PLDM_ERROR, response);
1742
1743 ASSERT_EQ(rc, PLDM_SUCCESS);
1744 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1745 ASSERT_EQ(response->hdr.instance_id, 0);
1746 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1747 ASSERT_EQ(response->hdr.command, PLDM_FILE_ACK_WITH_META_DATA);
1748 ASSERT_EQ(response->payload[0], PLDM_ERROR);
1749
1750 // response is NULL pointer
1751 rc = encode_file_ack_with_meta_data_resp(0, PLDM_SUCCESS, NULL);
1752
1753 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1754 }
1755
TEST(FileAckWithMetadata,testGoodDecodeResponse)1756 TEST(FileAckWithMetadata, testGoodDecodeResponse)
1757 {
1758 std::array<uint8_t,
1759 PLDM_FILE_ACK_WITH_META_DATA_RESP_BYTES + sizeof(pldm_msg_hdr)>
1760 responseMsg{};
1761
1762 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1763 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1764 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
1765 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1766 auto response = reinterpret_cast<pldm_file_ack_with_meta_data_resp*>(
1767 responsePtr->payload);
1768
1769 // Random value for completion code
1770 uint8_t completionCode = 0x0;
1771
1772 response->completion_code = completionCode;
1773
1774 uint8_t retCompletionCode = PLDM_SUCCESS;
1775
1776 // Invoke decode the read/write file response
1777 auto rc = decode_file_ack_with_meta_data_resp(responsePtr, payload_length,
1778 &retCompletionCode);
1779
1780 ASSERT_EQ(rc, PLDM_SUCCESS);
1781 ASSERT_EQ(completionCode, retCompletionCode);
1782 }
1783
TEST(FileAckWithMetadata,testBadDecodeResponse)1784 TEST(FileAckWithMetadata, testBadDecodeResponse)
1785 {
1786 uint8_t completionCode = 0;
1787
1788 // Request payload message is missing
1789 auto rc = decode_file_ack_with_meta_data_resp(NULL, 0, &completionCode);
1790 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1791
1792 std::array<uint8_t,
1793 PLDM_FILE_ACK_WITH_META_DATA_RESP_BYTES + sizeof(pldm_msg_hdr)>
1794 responseMsg{};
1795
1796 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1797 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
1798
1799 // Payload length is invalid
1800 rc = decode_file_ack_with_meta_data_resp(responsePtr, 0, &completionCode);
1801 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1802 }
1803
TEST(FileAckWithMetadata,testGoodEncodeRequest)1804 TEST(FileAckWithMetadata, testGoodEncodeRequest)
1805 {
1806 std::array<uint8_t,
1807 sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_WITH_META_DATA_REQ_BYTES>
1808 requestMsg{};
1809
1810 uint16_t fileType = 0xffff;
1811 uint32_t fileHandle = 0x12345678;
1812 uint8_t fileStatus = 0xff;
1813 uint32_t fileMetaData1 = 0xffffffff;
1814 uint32_t fileMetaData2 = 0xffffffff;
1815 uint32_t fileMetaData3 = 0xffffffff;
1816 uint32_t fileMetaData4 = 0xffffffff;
1817
1818 uint16_t fileTypeLe = htole16(fileType);
1819 uint32_t fileHandleLe = htole32(fileHandle);
1820 uint32_t fileMetaData1Le = htole32(fileMetaData1);
1821 uint32_t fileMetaData2Le = htole32(fileMetaData2);
1822 uint32_t fileMetaData3Le = htole32(fileMetaData3);
1823 uint32_t fileMetaData4Le = htole32(fileMetaData4);
1824
1825 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1826 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1827
1828 auto rc = encode_file_ack_with_meta_data_req(
1829 0, fileType, fileHandle, fileStatus, fileMetaData1, fileMetaData2,
1830 fileMetaData3, fileMetaData4, request);
1831
1832 ASSERT_EQ(rc, PLDM_SUCCESS);
1833 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
1834 ASSERT_EQ(request->hdr.instance_id, 0);
1835 ASSERT_EQ(request->hdr.type, PLDM_OEM);
1836 ASSERT_EQ(request->hdr.command, PLDM_FILE_ACK_WITH_META_DATA);
1837 ASSERT_EQ(0, memcmp(request->payload, &fileTypeLe, sizeof(fileTypeLe)));
1838 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe), &fileHandleLe,
1839 sizeof(fileHandleLe)));
1840 ASSERT_EQ(
1841 0, memcmp(request->payload + sizeof(fileTypeLe) + sizeof(fileHandleLe),
1842 &fileStatus, sizeof(fileStatus)));
1843 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1844 sizeof(fileHandleLe) + sizeof(fileStatus),
1845 &fileMetaData1Le, sizeof(fileMetaData1Le)));
1846 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1847 sizeof(fileHandleLe) + sizeof(fileStatus) +
1848 sizeof(fileMetaData1Le),
1849 &fileMetaData2Le, sizeof(fileMetaData2Le)));
1850
1851 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1852 sizeof(fileHandleLe) + sizeof(fileStatus) +
1853 sizeof(fileMetaData1Le) + sizeof(fileMetaData2Le),
1854 &fileMetaData3Le, sizeof(fileMetaData3Le)));
1855
1856 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
1857 sizeof(fileHandleLe) + sizeof(fileStatus) +
1858 sizeof(fileMetaData1Le) + sizeof(fileMetaData2Le) +
1859 sizeof(fileMetaData3Le),
1860 &fileMetaData4Le, sizeof(fileMetaData4Le)));
1861 }
1862
TEST(FileAckWithMetadata,testBadEncodeRequest)1863 TEST(FileAckWithMetadata, testBadEncodeRequest)
1864 {
1865 uint8_t fileType = 0xff;
1866 uint32_t fileHandle = 0;
1867 uint8_t fileStatus = 0;
1868 uint32_t fileMetaData1 = 0;
1869 uint32_t fileMetaData2 = 0;
1870 uint32_t fileMetaData3 = 0;
1871 uint32_t fileMetaData4 = 0;
1872
1873 // request is NULL pointer
1874 auto rc = encode_file_ack_with_meta_data_req(
1875 0, fileType, fileHandle, fileStatus, fileMetaData1, fileMetaData2,
1876 fileMetaData3, fileMetaData4, nullptr);
1877
1878 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1879 }
1880
TEST(FileAckWithMetadata,testGoodDecodeRequest)1881 TEST(FileAckWithMetadata, testGoodDecodeRequest)
1882 {
1883 std::array<uint8_t,
1884 sizeof(pldm_msg_hdr) + PLDM_FILE_ACK_WITH_META_DATA_REQ_BYTES>
1885 requestMsg{};
1886
1887 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1888 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1889 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
1890 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1891 auto request = reinterpret_cast<pldm_file_ack_with_meta_data_req*>(
1892 requestPtr->payload);
1893
1894 uint16_t fileType = 0xffff;
1895 uint32_t fileHandle = 0x12345678;
1896 uint8_t fileStatus = 0xff;
1897 uint32_t fileMetaData1 = 0x12345678;
1898 uint32_t fileMetaData2 = 0x87654321;
1899 uint32_t fileMetaData3 = 0x22121117;
1900 uint32_t fileMetaData4 = 0x12334345;
1901
1902 request->file_type = htole16(fileType);
1903 request->file_handle = htole32(fileHandle);
1904 request->file_status = fileStatus;
1905 request->file_meta_data_1 = htole32(fileMetaData1);
1906 request->file_meta_data_2 = htole32(fileMetaData2);
1907 request->file_meta_data_3 = htole32(fileMetaData3);
1908 request->file_meta_data_4 = htole32(fileMetaData4);
1909
1910 uint16_t retFileType = 0xffff;
1911 uint32_t retFileHandle = 0;
1912 uint8_t retFileStatus = 0;
1913 uint32_t retFileMetaData1 = 0;
1914 uint32_t retFileMetaData2 = 0;
1915 uint32_t retFileMetaData3 = 0;
1916 uint32_t retFileMetaData4 = 0;
1917
1918 auto rc = decode_file_ack_with_meta_data_req(
1919 requestPtr, payload_length, &retFileType, &retFileHandle,
1920 &retFileStatus, &retFileMetaData1, &retFileMetaData2, &retFileMetaData3,
1921 &retFileMetaData4);
1922 ASSERT_EQ(rc, PLDM_SUCCESS);
1923 ASSERT_EQ(fileType, retFileType);
1924 ASSERT_EQ(fileHandle, retFileHandle);
1925 ASSERT_EQ(fileStatus, retFileStatus);
1926 ASSERT_EQ(fileMetaData1, retFileMetaData1);
1927 ASSERT_EQ(fileMetaData2, retFileMetaData2);
1928 ASSERT_EQ(fileMetaData3, retFileMetaData3);
1929 ASSERT_EQ(fileMetaData4, retFileMetaData4);
1930 }
1931
TEST(FileAckWithMetadata,testBadDecodeRequest)1932 TEST(FileAckWithMetadata, testBadDecodeRequest)
1933 {
1934 uint16_t fileType = 0;
1935 uint32_t fileHandle = 0;
1936 uint8_t fileStatus = 0;
1937 uint32_t fileMetaData1 = 0;
1938 uint32_t fileMetaData2 = 0;
1939 uint32_t fileMetaData3 = 0;
1940 uint32_t fileMetaData4 = 0;
1941
1942 // Request payload message is missing
1943 auto rc = decode_file_ack_with_meta_data_req(
1944 NULL, 0, &fileType, &fileHandle, &fileStatus, &fileMetaData1,
1945 &fileMetaData2, &fileMetaData3, &fileMetaData4);
1946
1947 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1948
1949 std::array<uint8_t,
1950 PLDM_FILE_ACK_WITH_META_DATA_REQ_BYTES + sizeof(pldm_msg_hdr)>
1951 requestMsg{};
1952
1953 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1954 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
1955
1956 // Payload length is invalid
1957 rc = decode_file_ack_with_meta_data_req(
1958 requestPtr, 0, &fileType, &fileHandle, &fileStatus, &fileMetaData1,
1959 &fileMetaData2, &fileMetaData3, &fileMetaData4);
1960 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1961 }
1962
TEST(NewFileAvailableWithMetaData,testGoodEncodeResponse)1963 TEST(NewFileAvailableWithMetaData, testGoodEncodeResponse)
1964 {
1965 std::array<uint8_t, sizeof(pldm_msg_hdr) +
1966 PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_RESP_BYTES>
1967 responseMsg{};
1968
1969 uint8_t completionCode = 0x0;
1970
1971 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1972 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1973
1974 auto rc = encode_new_file_with_metadata_resp(0, completionCode, response);
1975
1976 ASSERT_EQ(rc, PLDM_SUCCESS);
1977 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1978 ASSERT_EQ(response->hdr.instance_id, 0);
1979 ASSERT_EQ(response->hdr.type, PLDM_OEM);
1980 ASSERT_EQ(response->hdr.command, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA);
1981 ASSERT_EQ(
1982 0, memcmp(response->payload, &completionCode, sizeof(completionCode)));
1983 }
1984
TEST(NewFileAvailableWithMetaData,testBadEncodeResponse)1985 TEST(NewFileAvailableWithMetaData, testBadEncodeResponse)
1986 {
1987 std::array<uint8_t, sizeof(pldm_msg_hdr) +
1988 PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_RESP_BYTES>
1989 responseMsg{};
1990 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1991 pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1992
1993 // completion code is PLDM_ERROR
1994 auto rc = encode_new_file_with_metadata_resp(0, PLDM_ERROR, response);
1995
1996 ASSERT_EQ(rc, PLDM_SUCCESS);
1997 ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
1998 ASSERT_EQ(response->hdr.instance_id, 0);
1999 ASSERT_EQ(response->hdr.type, PLDM_OEM);
2000 ASSERT_EQ(response->hdr.command, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA);
2001 ASSERT_EQ(response->payload[0], PLDM_ERROR);
2002
2003 // response is NULL pointer
2004 rc = encode_new_file_resp(0, PLDM_SUCCESS, NULL);
2005
2006 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2007 }
2008
TEST(NewFileAvailableWithMetaData,testGoodDecodeResponse)2009 TEST(NewFileAvailableWithMetaData, testGoodDecodeResponse)
2010 {
2011 std::array<uint8_t, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_RESP_BYTES +
2012 sizeof(pldm_msg_hdr)>
2013 responseMsg{};
2014
2015 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2016 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
2017 size_t payload_length = responseMsg.size() - sizeof(pldm_msg_hdr);
2018 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2019 auto response = reinterpret_cast<pldm_file_ack_with_meta_data_resp*>(
2020 responsePtr->payload);
2021
2022 // Random value for completion code
2023 uint8_t completionCode = 0x0;
2024
2025 response->completion_code = completionCode;
2026
2027 uint8_t retCompletionCode = PLDM_SUCCESS;
2028
2029 // Invoke decode the read/write file response
2030 auto rc = decode_new_file_with_metadata_resp(responsePtr, payload_length,
2031 &retCompletionCode);
2032
2033 ASSERT_EQ(rc, PLDM_SUCCESS);
2034 ASSERT_EQ(completionCode, retCompletionCode);
2035 }
2036
TEST(NewFileAvailableWithMetaData,testBadDecodeResponse)2037 TEST(NewFileAvailableWithMetaData, testBadDecodeResponse)
2038 {
2039 uint8_t completionCode = 0;
2040
2041 // Request payload message is missing
2042 auto rc = decode_new_file_with_metadata_resp(NULL, 0, &completionCode);
2043 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2044
2045 std::array<uint8_t, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_RESP_BYTES +
2046 sizeof(pldm_msg_hdr)>
2047 responseMsg{};
2048
2049 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2050 auto responsePtr = reinterpret_cast<pldm_msg*>(responseMsg.data());
2051
2052 // Payload length is invalid
2053 rc = decode_new_file_with_metadata_resp(responsePtr, 0, &completionCode);
2054 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2055 }
2056
TEST(NewFileAvailableWithMetaData,testGoodEncodeRequest)2057 TEST(NewFileAvailableWithMetaData, testGoodEncodeRequest)
2058 {
2059 std::array<uint8_t, sizeof(pldm_msg_hdr) +
2060 PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_REQ_BYTES>
2061 requestMsg{};
2062
2063 uint16_t fileType = 0xffff;
2064 uint32_t fileHandle = 0x12345678;
2065 uint32_t length = 0x13245768;
2066 uint64_t fileMetaData1 = 0xffffffff;
2067 uint32_t fileMetaData2 = 0xffffffff;
2068 uint32_t fileMetaData3 = 0xffffffff;
2069 uint32_t fileMetaData4 = 0xffffffff;
2070
2071 uint16_t fileTypeLe = htole16(fileType);
2072 uint32_t fileHandleLe = htole32(fileHandle);
2073 uint64_t lengthLe = htole64(length);
2074 uint32_t fileMetaData1Le = htole32(fileMetaData1);
2075 uint32_t fileMetaData2Le = htole32(fileMetaData2);
2076 uint32_t fileMetaData3Le = htole32(fileMetaData3);
2077 uint32_t fileMetaData4Le = htole32(fileMetaData4);
2078
2079 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2080 pldm_msg* request = reinterpret_cast<pldm_msg*>(requestMsg.data());
2081
2082 auto rc = encode_new_file_with_metadata_req(
2083 0, fileType, fileHandle, length, fileMetaData1, fileMetaData2,
2084 fileMetaData3, fileMetaData4, request);
2085
2086 ASSERT_EQ(rc, PLDM_SUCCESS);
2087 ASSERT_EQ(request->hdr.request, PLDM_REQUEST);
2088 ASSERT_EQ(request->hdr.instance_id, 0);
2089 ASSERT_EQ(request->hdr.type, PLDM_OEM);
2090 ASSERT_EQ(request->hdr.command, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA);
2091 ASSERT_EQ(0, memcmp(request->payload, &fileTypeLe, sizeof(fileTypeLe)));
2092 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe), &fileHandleLe,
2093 sizeof(fileHandleLe)));
2094 ASSERT_EQ(
2095 0, memcmp(request->payload + sizeof(fileTypeLe) + sizeof(fileHandleLe),
2096 &lengthLe, sizeof(lengthLe)));
2097
2098 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
2099 sizeof(fileHandleLe) + sizeof(lengthLe),
2100 &fileMetaData1Le, sizeof(fileMetaData1Le)));
2101
2102 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
2103 sizeof(fileHandleLe) + sizeof(lengthLe) +
2104 sizeof(fileMetaData1Le),
2105 &fileMetaData2Le, sizeof(fileMetaData2Le)));
2106
2107 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
2108 sizeof(fileHandleLe) + sizeof(lengthLe) +
2109 sizeof(fileMetaData1Le) + sizeof(fileMetaData2Le),
2110 &fileMetaData3Le, sizeof(fileMetaData3Le)));
2111
2112 ASSERT_EQ(0, memcmp(request->payload + sizeof(fileTypeLe) +
2113 sizeof(fileHandleLe) + sizeof(lengthLe) +
2114 sizeof(fileMetaData1Le) + sizeof(fileMetaData2Le) +
2115 sizeof(fileMetaData3Le),
2116 &fileMetaData4Le, sizeof(fileMetaData4Le)));
2117 }
2118
TEST(NewFileAvailableWithMetaData,testBadEncodeRequest)2119 TEST(NewFileAvailableWithMetaData, testBadEncodeRequest)
2120 {
2121 uint8_t fileType = 0xff;
2122 uint32_t fileHandle = 0;
2123 uint32_t length = 0;
2124 uint32_t fileMetaData1 = 0;
2125 uint32_t fileMetaData2 = 0;
2126 uint32_t fileMetaData3 = 0;
2127 uint32_t fileMetaData4 = 0;
2128
2129 // request is NULL pointer
2130 auto rc = encode_new_file_with_metadata_req(
2131 0, fileType, fileHandle, length, fileMetaData1, fileMetaData2,
2132 fileMetaData3, fileMetaData4, NULL);
2133
2134 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2135 }
2136
TEST(NewFileAvailableWithMetaData,testGoodDecodeRequest)2137 TEST(NewFileAvailableWithMetaData, testGoodDecodeRequest)
2138 {
2139 std::array<uint8_t, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_REQ_BYTES +
2140 sizeof(pldm_msg_hdr)>
2141 requestMsg{};
2142
2143 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2144 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
2145 size_t payload_length = requestMsg.size() - sizeof(pldm_msg_hdr);
2146 auto request =
2147 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2148 reinterpret_cast<pldm_new_file_with_metadata_req*>(requestPtr->payload);
2149
2150 // Random value for fileHandle and length
2151 uint16_t fileType = 0xffff;
2152 uint32_t fileHandle = 0x12345678;
2153 uint64_t length = 0x13245768;
2154 uint32_t fileMetaData1 = 0x12345678;
2155 uint32_t fileMetaData2 = 0x87654321;
2156 uint32_t fileMetaData3 = 0x22121117;
2157 uint32_t fileMetaData4 = 0x12334345;
2158
2159 request->file_type = htole16(fileType);
2160 request->file_handle = htole32(fileHandle);
2161 request->length = htole64(length);
2162 request->file_meta_data_1 = htole32(fileMetaData1);
2163 request->file_meta_data_2 = htole32(fileMetaData2);
2164 request->file_meta_data_3 = htole32(fileMetaData3);
2165 request->file_meta_data_4 = htole32(fileMetaData4);
2166
2167 uint16_t retFileType = 0xffff;
2168 uint32_t retFileHandle = 0;
2169 uint64_t retLength = 0;
2170 uint32_t retFileMetaData1 = 0;
2171 uint32_t retFileMetaData2 = 0;
2172 uint32_t retFileMetaData3 = 0;
2173 uint32_t retFileMetaData4 = 0;
2174
2175 // Invoke decode the read file request
2176 auto rc = decode_new_file_with_metadata_req(
2177 requestPtr, payload_length, &retFileType, &retFileHandle, &retLength,
2178 &retFileMetaData1, &retFileMetaData2, &retFileMetaData3,
2179 &retFileMetaData4);
2180
2181 ASSERT_EQ(rc, PLDM_SUCCESS);
2182 ASSERT_EQ(fileType, retFileType);
2183 ASSERT_EQ(fileHandle, retFileHandle);
2184 ASSERT_EQ(length, retLength);
2185 ASSERT_EQ(fileMetaData1, retFileMetaData1);
2186 ASSERT_EQ(fileMetaData2, retFileMetaData2);
2187 ASSERT_EQ(fileMetaData3, retFileMetaData3);
2188 ASSERT_EQ(fileMetaData4, retFileMetaData4);
2189 }
2190
TEST(NewFileAvailableWithMetaData,testBadDecodeRequest)2191 TEST(NewFileAvailableWithMetaData, testBadDecodeRequest)
2192 {
2193 uint16_t fileType = 0;
2194 uint32_t fileHandle = 0;
2195 uint64_t length = 0;
2196 uint32_t fileMetaData1 = 0;
2197 uint32_t fileMetaData2 = 0;
2198 uint32_t fileMetaData3 = 0;
2199 uint32_t fileMetaData4 = 0;
2200
2201 // Request payload message is missing
2202 auto rc = decode_new_file_with_metadata_req(
2203 NULL, 0, &fileType, &fileHandle, &length, &fileMetaData1,
2204 &fileMetaData2, &fileMetaData3, &fileMetaData4);
2205
2206 ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2207
2208 std::array<uint8_t, PLDM_NEW_FILE_AVAILABLE_WITH_META_DATA_REQ_BYTES +
2209 sizeof(pldm_msg_hdr)>
2210 requestMsg{};
2211
2212 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2213 auto requestPtr = reinterpret_cast<pldm_msg*>(requestMsg.data());
2214
2215 // Payload length is invalid
2216 rc = decode_new_file_with_metadata_req(
2217 requestPtr, 0, &fileType, &fileHandle, &length, &fileMetaData1,
2218 &fileMetaData2, &fileMetaData3, &fileMetaData4);
2219 ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2220 }
2221