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
TEST(EncodeDfOpenReq,GoodTest)15 TEST(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
TEST(EncodeDfOpenReq,BadTestUnAllocatedPtrParams)38 TEST(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
TEST(EncodeDfOpenReq,BadTestInvalidExpectedOutputMsgLength)61 TEST(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
TEST(DecodeDfOpenResp,GoodTest)79 TEST(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
TEST(DecodeDfOpenResp,BadTestUnAllocatedPtrParams)110 TEST(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
TEST(DecodeDfOpenResp,BadTestInvalidExpectedInputMsgLength)141 TEST(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
167
168 #ifdef LIBPLDM_API_TESTING
TEST(EncodeDfCloseReq,GoodTest)169 TEST(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
TEST(EncodeDfCloseReq,BadTestUnAllocatedPtrParams)192 TEST(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
TEST(EncodeDfCloseReq,BadTestInvalidExpectedOutputMsgLength)215 TEST(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
TEST(DecodeDfCloseResp,GoodTest)233 TEST(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
TEST(DecodeDfCloseResp,BadTestUnAllocatedPtrParams)262 TEST(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
289
290 #ifdef LIBPLDM_API_TESTING
TEST(EncodeDfHeartbeatReq,GoodTest)291 TEST(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
TEST(EncodeDfHeartbeatReq,BadTestUnAllocatedPtrParams)313 TEST(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
TEST(EncodeDfHeartbeatReq,BadTestInvalidExpectedOutputMsgLength)335 TEST(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
TEST(DecodeDfHeartbeatResp,GoodTest)353 TEST(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
TEST(DecodeDfHeartbeatResp,BadTestUnAllocatedPtrParams)385 TEST(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
TEST(DecodeDfHeartbeatResp,BadTestInvalidExpectedInputMsgLength)418 TEST(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
444