Gitiles
Code Review Sign In
gerrit.openbmc.org / openbmc / libpldm / 075a7dc6867dc72314b54df69cebe4c83ed47d31 / . / tests / dsp / file.cpp
blob: 93ba8475525bc3bd1238bad2a57716d0327aa503 [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