Gitiles
Code Review Sign In
gerrit.openbmc.org / openbmc / libpldm / 340bb6286f6e5fd55dc05fe1915e7f179992c500 / . / tests / dsp / file.cpp
blob: 71dcce30d96d2d0665abe9f2ad2392d4a8f95f38 [file] [log] [blame]
Chau Lycf26f2a2025-03-18 10:39:03 +0000[diff] [blame]1#include <libpldm/file.h>
2#include <libpldm/pldm_types.h>
3
4#include <array>
5#include <cstdint>
6#include <cstring>
7#include <vector>
8
9#include "msgbuf.h"
10
11#include <gmock/gmock.h>
12#include <gtest/gtest.h>
13
14#ifdef LIBPLDM_API_TESTING
15TEST(EncodeDfOpenReq, GoodTest)
16{
17 uint8_t instance_id = 0;
18 uint16_t file_identifier = 0x0100;
19 bitfield16_t file_attribute;
20 file_attribute.value = 0x0400;
21 std::array<uint8_t, PLDM_DF_OPEN_REQ_BYTES> requestMsg = {0x00, 0x01, 0x00,
22 0x04};
23
24 const struct pldm_file_df_open_req req_data = {file_identifier,
25 file_attribute};
26
27 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES);
28 auto rc = encode_pldm_file_df_open_req(instance_id, &req_data, requestPtr,
29 PLDM_DF_OPEN_REQ_BYTES);
30
31 ASSERT_EQ(rc, 0);
32 EXPECT_EQ(
33 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg)));
34}
35#endif
36
37#ifdef LIBPLDM_API_TESTING
38TEST(EncodeDfOpenReq, BadTestUnAllocatedPtrParams)
39{
40 uint8_t instance_id = 0;
41 uint16_t file_identifier = 0x0100;
42 bitfield16_t file_attribute;
43 file_attribute.value = 0x0400;
44 int rc;
45
46 const struct pldm_file_df_open_req req_data = {file_identifier,
47 file_attribute};
48
49 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES);
50 rc = encode_pldm_file_df_open_req(instance_id, &req_data, nullptr,
51 PLDM_DF_OPEN_REQ_BYTES);
52 EXPECT_EQ(rc, -EINVAL);
53
54 rc = encode_pldm_file_df_open_req(instance_id, nullptr, requestPtr,
55 PLDM_DF_OPEN_REQ_BYTES);
56 EXPECT_EQ(rc, -EINVAL);
57}
58#endif
59
60#ifdef LIBPLDM_API_TESTING
61TEST(EncodeDfOpenReq, BadTestInvalidExpectedOutputMsgLength)
62{
63 uint8_t instance_id = 0;
64 uint16_t file_identifier = 0x0100;
65 bitfield16_t file_attribute;
66 file_attribute.value = 0x0400;
67 int rc;
68
69 const struct pldm_file_df_open_req req_data = {file_identifier,
70 file_attribute};
71
72 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES);
73 rc = encode_pldm_file_df_open_req(instance_id, &req_data, requestPtr, 1);
74 EXPECT_EQ(rc, -EOVERFLOW);
75}
76#endif
77
78#ifdef LIBPLDM_API_TESTING
79TEST(DecodeDfOpenResp, GoodTest)
80{
81 uint8_t completion_code = PLDM_SUCCESS;
82 uint16_t file_descriptor = 20;
83
84 struct pldm_file_df_open_resp resp_data = {};
85
86 PLDM_MSGBUF_DEFINE_P(buf);
87 int rc;
88
89 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
90
91 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
92
93 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
94 ASSERT_EQ(rc, 0);
95
96 pldm_msgbuf_insert_uint8(buf, completion_code);
97 pldm_msgbuf_insert_uint16(buf, file_descriptor);
98
99 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
100
101 rc = decode_pldm_file_df_open_resp(responseMsg, payload_length, &resp_data);
102
103 ASSERT_EQ(rc, 0);
104 EXPECT_EQ(resp_data.completion_code, completion_code);
105 EXPECT_EQ(resp_data.file_descriptor, file_descriptor);
106}
107#endif
108
109#ifdef LIBPLDM_API_TESTING
110TEST(DecodeDfOpenResp, BadTestUnAllocatedPtrParams)
111{
112 uint8_t completion_code = PLDM_SUCCESS;
113 uint16_t file_descriptor = 20;
114
115 struct pldm_file_df_open_resp resp_data = {};
116
117 PLDM_MSGBUF_DEFINE_P(buf);
118 int rc;
119
120 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
121
122 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
123
124 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
125 ASSERT_EQ(rc, 0);
126
127 pldm_msgbuf_insert_uint8(buf, completion_code);
128 pldm_msgbuf_insert_uint16(buf, file_descriptor);
129
130 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
131
132 rc = decode_pldm_file_df_open_resp(nullptr, payload_length, &resp_data);
133 EXPECT_EQ(rc, -EINVAL);
134
135 rc = decode_pldm_file_df_open_resp(responseMsg, payload_length, nullptr);
136 EXPECT_EQ(rc, -EINVAL);
137}
138#endif
139
140#ifdef LIBPLDM_API_TESTING
141TEST(DecodeDfOpenResp, BadTestInvalidExpectedInputMsgLength)
142{
143 uint8_t completion_code = PLDM_SUCCESS;
144 uint16_t file_descriptor = 20;
145
146 struct pldm_file_df_open_resp resp_data = {};
147
148 PLDM_MSGBUF_DEFINE_P(buf);
149 int rc;
150
151 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
152
153 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
154
155 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
156 ASSERT_EQ(rc, 0);
157
158 pldm_msgbuf_insert_uint8(buf, completion_code);
159 pldm_msgbuf_insert_uint16(buf, file_descriptor);
160
161 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
162
163 rc = decode_pldm_file_df_open_resp(responseMsg, 0, &resp_data);
164 EXPECT_EQ(rc, -EOVERFLOW);
165}
166#endif
Chau Ly7286ca62025-03-26 05:47:18 +0000[diff] [blame]167
168#ifdef LIBPLDM_API_TESTING
169TEST(EncodeDfCloseReq, GoodTest)
170{
171 uint8_t instance_id = 0;
172 uint16_t file_descriptor = 0x0200;
173 bitfield16_t df_close_options;
174 df_close_options.value = 0x0100;
175 std::array<uint8_t, PLDM_DF_CLOSE_REQ_BYTES> requestMsg = {0x00, 0x02, 0x00,
176 0x01};
177
178 const struct pldm_file_df_close_req req_data = {file_descriptor,
179 df_close_options};
180
181 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES);
182 auto rc = encode_pldm_file_df_close_req(instance_id, &req_data, requestPtr,
183 PLDM_DF_CLOSE_REQ_BYTES);
184
185 ASSERT_EQ(rc, 0);
186 EXPECT_EQ(
187 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg)));
188}
189#endif
190
191#ifdef LIBPLDM_API_TESTING
192TEST(EncodeDfCloseReq, BadTestUnAllocatedPtrParams)
193{
194 uint8_t instance_id = 0;
195 uint16_t file_descriptor = 0x0200;
196 bitfield16_t df_close_options;
197 df_close_options.value = 0x0100;
198 int rc;
199
200 const struct pldm_file_df_close_req req_data = {file_descriptor,
201 df_close_options};
202
203 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_CLOSE_REQ_BYTES);
204 rc = encode_pldm_file_df_close_req(instance_id, &req_data, nullptr,
205 PLDM_DF_CLOSE_REQ_BYTES);
206 EXPECT_EQ(rc, -EINVAL);
207
208 rc = encode_pldm_file_df_close_req(instance_id, nullptr, requestPtr,
209 PLDM_DF_CLOSE_REQ_BYTES);
210 EXPECT_EQ(rc, -EINVAL);
211}
212#endif
213
214#ifdef LIBPLDM_API_TESTING
215TEST(EncodeDfCloseReq, BadTestInvalidExpectedOutputMsgLength)
216{
217 uint8_t instance_id = 0;
218 uint16_t file_descriptor = 0x0200;
219 bitfield16_t df_close_options;
220 df_close_options.value = 0x0100;
221 int rc;
222
223 const struct pldm_file_df_close_req req_data = {file_descriptor,
224 df_close_options};
225
226 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_CLOSE_REQ_BYTES);
227 rc = encode_pldm_file_df_close_req(instance_id, &req_data, requestPtr, 1);
228 EXPECT_EQ(rc, -EOVERFLOW);
229}
230#endif
231
232#ifdef LIBPLDM_API_TESTING
233TEST(DecodeDfCloseResp, GoodTest)
234{
235 uint8_t completion_code = PLDM_SUCCESS;
236
237 struct pldm_file_df_close_resp resp_data = {};
238
239 PLDM_MSGBUF_DEFINE_P(buf);
240 int rc;
241
242 static constexpr const size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES;
243
244 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
245
246 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
247 ASSERT_EQ(rc, 0);
248
249 pldm_msgbuf_insert_uint8(buf, completion_code);
250
251 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
252
253 rc =
254 decode_pldm_file_df_close_resp(responseMsg, payload_length, &resp_data);
255
256 ASSERT_EQ(rc, 0);
257 EXPECT_EQ(resp_data.completion_code, completion_code);
258}
259#endif
260
261#ifdef LIBPLDM_API_TESTING
262TEST(DecodeDfCloseResp, BadTestUnAllocatedPtrParams)
263{
264 uint8_t completion_code = PLDM_SUCCESS;
265
266 struct pldm_file_df_close_resp resp_data = {};
267
268 PLDM_MSGBUF_DEFINE_P(buf);
269 int rc;
270
271 static constexpr const size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES;
272
273 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
274
275 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
276 ASSERT_EQ(rc, 0);
277
278 pldm_msgbuf_insert_uint8(buf, completion_code);
279
280 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
281
282 rc = decode_pldm_file_df_close_resp(nullptr, payload_length, &resp_data);
283 EXPECT_EQ(rc, -EINVAL);
284
285 rc = decode_pldm_file_df_close_resp(responseMsg, payload_length, nullptr);
286 EXPECT_EQ(rc, -EINVAL);
287}
288#endif
Chau Ly58273fb2025-03-26 08:26:49 +0000[diff] [blame]289
290#ifdef LIBPLDM_API_TESTING
291TEST(EncodeDfHeartbeatReq, GoodTest)
292{
293 uint8_t instance_id = 0;
294 uint16_t file_descriptor = 0x0200;
295 uint32_t requester_max_interval = 0x88130000; // 5000 ms
296 std::array<uint8_t, PLDM_DF_HEARTBEAT_REQ_BYTES> requestMsg = {
297 0x00, 0x02, 0x00, 0x00, 0x13, 0x88};
298
299 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor,
300 requester_max_interval};
301
302 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
303 auto rc = encode_pldm_file_df_heartbeat_req(
304 instance_id, &req_data, requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
305
306 ASSERT_EQ(rc, 0);
307 EXPECT_EQ(
308 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg)));
309}
310#endif
311
312#ifdef LIBPLDM_API_TESTING
313TEST(EncodeDfHeartbeatReq, BadTestUnAllocatedPtrParams)
314{
315 uint8_t instance_id = 0;
316 uint16_t file_descriptor = 0x0200;
317 uint32_t requester_max_interval = 0x88130000; // 5000 ms
318 int rc;
319
320 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor,
321 requester_max_interval};
322
323 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
324 rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, nullptr,
325 PLDM_DF_HEARTBEAT_REQ_BYTES);
326 EXPECT_EQ(rc, -EINVAL);
327
328 rc = encode_pldm_file_df_heartbeat_req(instance_id, nullptr, requestPtr,
329 PLDM_DF_HEARTBEAT_REQ_BYTES);
330 EXPECT_EQ(rc, -EINVAL);
331}
332#endif
333
334#ifdef LIBPLDM_API_TESTING
335TEST(EncodeDfHeartbeatReq, BadTestInvalidExpectedOutputMsgLength)
336{
337 uint8_t instance_id = 0;
338 uint16_t file_descriptor = 0x0200;
339 uint32_t requester_max_interval = 0x88130000; // 5000 ms
340 int rc;
341
342 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor,
343 requester_max_interval};
344
345 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES);
346 rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, requestPtr,
347 1);
348 EXPECT_EQ(rc, -EOVERFLOW);
349}
350#endif
351
352#ifdef LIBPLDM_API_TESTING
353TEST(DecodeDfHeartbeatResp, GoodTest)
354{
355 uint8_t completion_code = PLDM_SUCCESS;
356 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms
357
358 struct pldm_file_df_heartbeat_resp resp_data = {};
359
360 PLDM_MSGBUF_DEFINE_P(buf);
361 int rc;
362
363 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES;
364
365 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
366
367 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
368 ASSERT_EQ(rc, 0);
369
370 pldm_msgbuf_insert_uint8(buf, completion_code);
371 pldm_msgbuf_insert_uint32(buf, responder_max_interval);
372
373 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
374
375 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length,
376 &resp_data);
377
378 ASSERT_EQ(rc, 0);
379 EXPECT_EQ(resp_data.completion_code, completion_code);
380 EXPECT_EQ(resp_data.responder_max_interval, responder_max_interval);
381}
382#endif
383
384#ifdef LIBPLDM_API_TESTING
385TEST(DecodeDfHeartbeatResp, BadTestUnAllocatedPtrParams)
386{
387 uint8_t completion_code = PLDM_SUCCESS;
388 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms
389
390 struct pldm_file_df_heartbeat_resp resp_data = {};
391
392 PLDM_MSGBUF_DEFINE_P(buf);
393 int rc;
394
395 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES;
396
397 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
398
399 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
400 ASSERT_EQ(rc, 0);
401
402 pldm_msgbuf_insert_uint8(buf, completion_code);
403 pldm_msgbuf_insert_uint32(buf, responder_max_interval);
404
405 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
406
407 rc =
408 decode_pldm_file_df_heartbeat_resp(nullptr, payload_length, &resp_data);
409 EXPECT_EQ(rc, -EINVAL);
410
411 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length,
412 nullptr);
413 EXPECT_EQ(rc, -EINVAL);
414}
415#endif
416
417#ifdef LIBPLDM_API_TESTING
418TEST(DecodeDfHeartbeatResp, BadTestInvalidExpectedInputMsgLength)
419{
420 uint8_t completion_code = PLDM_SUCCESS;
421 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms
422
423 struct pldm_file_df_heartbeat_resp resp_data = {};
424
425 PLDM_MSGBUF_DEFINE_P(buf);
426 int rc;
427
428 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES;
429
430 PLDM_MSG_DEFINE_P(responseMsg, payload_length);
431
432 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length);
433 ASSERT_EQ(rc, 0);
434
435 pldm_msgbuf_insert_uint8(buf, completion_code);
436 pldm_msgbuf_insert_uint32(buf, responder_max_interval);
437
438 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
439
440 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, 0, &resp_data);
441 EXPECT_EQ(rc, -EOVERFLOW);
442}
443#endif
John Chung76c9b192025-07-09 22:35:36 -0500[diff] [blame]444
445#ifdef LIBPLDM_API_TESTING
446TEST(EncodeDfOpenResp, GoodTest)
447{
448 uint8_t instance_id = 0;
449 uint8_t completion_code = PLDM_SUCCESS;
450 uint16_t file_descriptor = 0x0100;
451 size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
452 std::array<uint8_t, PLDM_DF_OPEN_RESP_BYTES> responseMsg = {0x00, 0x00,
453 0x01};
454
455 const struct pldm_file_df_open_resp resp_data = {completion_code,
456 file_descriptor};
457
458 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
459 auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data,
460 responsePtr, &payload_length);
461
462 ASSERT_EQ(rc, 0);
463 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(),
464 sizeof(responseMsg)));
465 EXPECT_EQ(payload_length, PLDM_DF_OPEN_RESP_BYTES);
466}
467#endif
468
469#ifdef LIBPLDM_API_TESTING
470TEST(EncodeDfOpenResp, BadTestUnAllocatedPtrParams)
471{
472 uint8_t instance_id = 0;
473 uint8_t completion_code = PLDM_SUCCESS;
474 uint16_t file_descriptor = 0x0100;
475 int rc;
476 size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
477 const struct pldm_file_df_open_resp resp_data = {completion_code,
478 file_descriptor};
479
480 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
481 rc = encode_pldm_file_df_open_resp(instance_id, &resp_data, nullptr,
482 &payload_length);
483 EXPECT_EQ(rc, -EINVAL);
484
485 rc = encode_pldm_file_df_open_req(instance_id, nullptr, responsePtr,
486 PLDM_DF_OPEN_RESP_BYTES);
487 EXPECT_EQ(rc, -EINVAL);
488}
489#endif
490
491#ifdef LIBPLDM_API_TESTING
492TEST(EncodeDfOpenResp, BadTestInvalidExpectedOutputMsgLength)
493{
494 uint8_t instance_id = 0;
495 uint8_t completion_code = PLDM_SUCCESS;
496 uint16_t file_descriptor = 0x0100;
497 size_t payload_length;
498
499 const struct pldm_file_df_open_resp resp_data = {completion_code,
500 file_descriptor};
501
502 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
503 payload_length = 1;
504 auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data,
505 responsePtr, &payload_length);
506 EXPECT_EQ(rc, -EOVERFLOW);
507}
508#endif
509
510#ifdef LIBPLDM_API_TESTING
511TEST(EncodeDfOpenResp, GoodTestCompletionCode)
512{
513 uint8_t instance_id = 0;
514 uint8_t completion_code = PLDM_FILE_CC_INVALID_FILE_DESCRIPTOR;
515 uint16_t file_descriptor = 0x0100;
516 size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
517
518 const struct pldm_file_df_open_resp resp_data = {completion_code,
519 file_descriptor};
520
521 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
522 auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data,
523 responsePtr, &payload_length);
524 EXPECT_EQ(rc, 0);
525 EXPECT_EQ(payload_length, 1); // Completion code only
526}
527#endif
528
529#ifdef LIBPLDM_API_TESTING
530TEST(DecodeDfOpenReq, GoodTest)
531{
532 uint16_t file_identifier = 0x0100;
533 bitfield16_t file_attribute;
534 file_attribute.value = 0x0400;
535
536 struct pldm_file_df_open_req req_data = {};
537
538 PLDM_MSGBUF_DEFINE_P(buf);
539 int rc;
540
541 static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES;
542
543 PLDM_MSG_DEFINE_P(requestMsg, payload_length);
544
545 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
546 ASSERT_EQ(rc, 0);
547
548 pldm_msgbuf_insert_uint16(buf, file_identifier);
549 pldm_msgbuf_insert_uint16(buf, file_attribute.value);
550
551 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
552
553 rc = decode_pldm_file_df_open_req(requestMsg, payload_length, &req_data);
554
555 ASSERT_EQ(rc, 0);
556 EXPECT_EQ(req_data.file_identifier, file_identifier);
557 EXPECT_EQ(req_data.file_attribute.value, file_attribute.value);
558}
559#endif
560
561#ifdef LIBPLDM_API_TESTING
562TEST(DecodeDfOpenReq, BadTestUnAllocatedPtrParams)
563{
564 uint16_t file_identifier = 0x0100;
565 bitfield16_t file_attribute;
566 file_attribute.value = 0x0400;
567
568 struct pldm_file_df_open_req req_data = {};
569
570 PLDM_MSGBUF_DEFINE_P(buf);
571 int rc;
572
573 static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES;
574
575 PLDM_MSG_DEFINE_P(requestMsg, payload_length);
576
577 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
578 ASSERT_EQ(rc, 0);
579
580 pldm_msgbuf_insert_uint16(buf, file_identifier);
581 pldm_msgbuf_insert_uint16(buf, file_attribute.value);
582
583 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
584
585 rc = decode_pldm_file_df_open_req(nullptr, payload_length, &req_data);
586 EXPECT_EQ(rc, -EINVAL);
587
588 rc = decode_pldm_file_df_open_req(requestMsg, payload_length, nullptr);
589 EXPECT_EQ(rc, -EINVAL);
590}
591#endif
592
593#ifdef LIBPLDM_API_TESTING
594TEST(DecodeDfOpenReq, BadTestInvalidExpectedInputMsgLength)
595{
596 uint16_t file_identifier = 0x0100;
597 bitfield16_t file_attribute;
598 file_attribute.value = 0x0400;
599
600 struct pldm_file_df_open_req req_data = {};
601
602 PLDM_MSGBUF_DEFINE_P(buf);
603 int rc;
604
605 static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES;
606
607 PLDM_MSG_DEFINE_P(requestMsg, payload_length);
608
609 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
610 ASSERT_EQ(rc, 0);
611
612 pldm_msgbuf_insert_uint16(buf, file_identifier);
613 pldm_msgbuf_insert_uint16(buf, file_attribute.value);
614
615 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
616
617 rc = decode_pldm_file_df_open_req(requestMsg, 0, &req_data);
618 EXPECT_EQ(rc, -EOVERFLOW);
619}
620#endif
621
622#ifdef LIBPLDM_API_TESTING
623TEST(EncodeDfCloseResp, GoodTest)
624{
625 uint8_t instance_id = 0;
626 size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES;
627 std::array<uint8_t, PLDM_DF_CLOSE_RESP_BYTES> responseMsg = {PLDM_SUCCESS};
628
629 const struct pldm_file_df_close_resp resp_data = {PLDM_SUCCESS};
630
631 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_CLOSE_RESP_BYTES);
632
633 auto rc = encode_pldm_file_df_close_resp(instance_id, &resp_data,
634 responsePtr, &payload_length);
635
636 ASSERT_EQ(rc, 0);
637 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(),
638 sizeof(responseMsg)));
639}
640#endif
641
642#ifdef LIBPLDM_API_TESTING
643TEST(EncodeDfCloseResp, BadTestUnAllocatedPtrParams)
644{
645 uint8_t instance_id = 0;
646 size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES;
647 const struct pldm_file_df_close_resp resp_data = {PLDM_SUCCESS};
648 int rc;
649
650 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_CLOSE_RESP_BYTES);
651
652 rc = encode_pldm_file_df_close_resp(instance_id, &resp_data, nullptr,
653 &payload_length);
654 EXPECT_EQ(rc, -EINVAL);
655
656 rc = encode_pldm_file_df_close_resp(instance_id, nullptr, responsePtr,
657 &payload_length);
658 EXPECT_EQ(rc, -EINVAL);
659}
660#endif
661
662#ifdef LIBPLDM_API_TESTING
663TEST(DecodeDfCloseReq, GoodTest)
664{
665 uint16_t file_descriptor = 0x1000;
666 bitfield16_t df_close_options;
667 df_close_options.value = 0x4000;
668
669 struct pldm_file_df_close_req req_data = {};
670
671 PLDM_MSGBUF_DEFINE_P(buf);
672 int rc;
673
674 static constexpr const size_t payload_length = PLDM_DF_CLOSE_REQ_BYTES;
675
676 PLDM_MSG_DEFINE_P(requestMsg, payload_length);
677
678 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
679 ASSERT_EQ(rc, 0);
680
681 pldm_msgbuf_insert_uint16(buf, file_descriptor);
682 pldm_msgbuf_insert_uint16(buf, df_close_options.value);
683
684 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
685
686 rc = decode_pldm_file_df_close_req(requestMsg, payload_length, &req_data);
687
688 ASSERT_EQ(rc, 0);
689 EXPECT_EQ(req_data.file_descriptor, file_descriptor);
690 EXPECT_EQ(req_data.df_close_options.value, df_close_options.value);
691}
692#endif
693
694#ifdef LIBPLDM_API_TESTING
695TEST(DecodeDfCloseReq, BadTestUnAllocatedPtrParams)
696{
697 uint16_t file_descriptor = 0x1000;
698 bitfield16_t df_close_options;
699 df_close_options.value = 0x4000;
700
701 struct pldm_file_df_close_req req_data = {};
702
703 PLDM_MSGBUF_DEFINE_P(buf);
704 int rc;
705
706 static constexpr const size_t payload_length = PLDM_DF_CLOSE_REQ_BYTES;
707
708 PLDM_MSG_DEFINE_P(requestMsg, payload_length);
709
710 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
711 ASSERT_EQ(rc, 0);
712
713 pldm_msgbuf_insert_uint16(buf, file_descriptor);
714 pldm_msgbuf_insert_uint16(buf, df_close_options.value);
715
716 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
717
718 rc = decode_pldm_file_df_close_req(nullptr, payload_length, &req_data);
719 EXPECT_EQ(rc, -EINVAL);
720
721 rc = decode_pldm_file_df_close_req(requestMsg, payload_length, nullptr);
722 EXPECT_EQ(rc, -EINVAL);
723}
724#endif