blob: 4d03574bf4f655d0033f3ec92222e6b69270818a [file] [log] [blame]
Andrew Jeffery9a6ba892023-07-18 22:22:14 +09301#include "libpldm/transport.h"
2
3#include "array.h"
4#include "transport/test.h"
5
6#include <gtest/gtest.h>
7
Andrew Jeffery9a6ba892023-07-18 22:22:14 +09308TEST(Transport, create)
9{
10 struct pldm_transport_test* test = NULL;
11
12 EXPECT_EQ(pldm_transport_test_init(&test, NULL, 0), 0);
13 EXPECT_NE(pldm_transport_test_core(test), nullptr);
14 pldm_transport_test_destroy(test);
15}
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093016
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093017TEST(Transport, send_one)
18{
19 const uint8_t msg[] = {0x81, 0x00, 0x01, 0x01};
20 const struct pldm_transport_test_descriptor seq[] = {
21 {
22 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
23 .send_msg =
24 {
25 .dst = 1,
26 .msg = msg,
27 .len = sizeof(msg),
28 },
29 },
30 };
31 struct pldm_transport_test* test = NULL;
32 struct pldm_transport* ctx;
33 int rc;
34
35 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
36 ctx = pldm_transport_test_core(test);
37 rc = pldm_transport_send_msg(ctx, 1, msg, sizeof(msg));
38 EXPECT_EQ(rc, PLDM_REQUESTER_SUCCESS);
39 pldm_transport_test_destroy(test);
40}
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093041
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093042TEST(Transport, recv_one)
43{
44 uint8_t msg[] = {0x01, 0x00, 0x01, 0x00};
Rashmica Gupta24576292023-07-31 14:02:41 +100045 const pldm_tid_t src_tid = 1;
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093046 const struct pldm_transport_test_descriptor seq[] = {
47 {
48 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
49 .recv_msg =
50 {
Rashmica Gupta24576292023-07-31 14:02:41 +100051 .src = src_tid,
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093052 .msg = msg,
53 .len = sizeof(msg),
54 },
55 },
56 };
57 struct pldm_transport_test* test = NULL;
58 struct pldm_transport* ctx;
59 void* recvd;
60 size_t len;
61 int rc;
Rashmica Gupta24576292023-07-31 14:02:41 +100062 pldm_tid_t tid;
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093063
64 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
65 ctx = pldm_transport_test_core(test);
Rashmica Gupta24576292023-07-31 14:02:41 +100066 rc = pldm_transport_recv_msg(ctx, &tid, &recvd, &len);
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093067 EXPECT_EQ(rc, PLDM_REQUESTER_SUCCESS);
68 EXPECT_EQ(len, sizeof(msg));
69 EXPECT_EQ(memcmp(recvd, msg, len), 0);
Rashmica Gupta24576292023-07-31 14:02:41 +100070 EXPECT_EQ(tid, src_tid);
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093071 free(recvd);
72 pldm_transport_test_destroy(test);
73}
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093074
Andrew Jeffery9a6ba892023-07-18 22:22:14 +093075TEST(Transport, send_recv_one)
76{
77 uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
78 uint8_t resp[] = {0x01, 0x00, 0x01, 0x00};
79 const struct pldm_transport_test_descriptor seq[] = {
80 {
81 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
82 .send_msg =
83 {
84 .dst = 1,
85 .msg = req,
86 .len = sizeof(req),
87 },
88 },
89 {
90 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
91 .latency =
92 {
93 .it_interval = {0, 0},
94 .it_value = {1, 0},
95 },
96 },
97 {
98 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
99 .recv_msg =
100 {
101 .src = 1,
102 .msg = resp,
103 .len = sizeof(resp),
104 },
105 },
106 };
107 struct pldm_transport_test* test = NULL;
108 struct pldm_transport* ctx;
109 size_t len;
110 void* msg;
111 int rc;
112
113 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
114 ctx = pldm_transport_test_core(test);
115 rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
116 EXPECT_EQ(rc, PLDM_REQUESTER_SUCCESS);
117 EXPECT_EQ(len, sizeof(resp));
118 EXPECT_EQ(memcmp(msg, resp, len), 0);
119 free(msg);
120 pldm_transport_test_destroy(test);
121}
Andrew Jeffery9a6ba892023-07-18 22:22:14 +0930122
Andrew Jeffery9a6ba892023-07-18 22:22:14 +0930123TEST(Transport, send_recv_timeout)
124{
125 uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
126 const struct pldm_transport_test_descriptor seq[] = {
127 {
128 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
129 .send_msg =
130 {
131 .dst = 1,
132 .msg = req,
133 .len = sizeof(req),
134 },
135 },
136 {
137 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
138 .latency =
139 {
140 .it_interval = {0, 0},
141 .it_value = {5, 0},
142 },
143 },
144 };
145 struct pldm_transport_test* test = NULL;
146 struct pldm_transport* ctx;
147 size_t len;
148 void* msg;
149 int rc;
150
151 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
152 ctx = pldm_transport_test_core(test);
153 rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
154 EXPECT_EQ(rc, PLDM_REQUESTER_RECV_FAIL);
155 pldm_transport_test_destroy(test);
156}
Thu Nguyenef485062023-07-14 23:36:21 +0700157
Thu Nguyenef485062023-07-14 23:36:21 +0700158TEST(Transport, send_recv_unwanted)
159{
160 uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
161 uint8_t resp[] = {0x02, 0x00, 0x01, 0x00};
162 const struct pldm_transport_test_descriptor seq[] = {
163 {
164 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
165 .send_msg =
166 {
167 .dst = 1,
168 .msg = req,
169 .len = sizeof(req),
170 },
171 },
172 {
173 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
174 .latency =
175 {
176 .it_interval = {0, 0},
177 .it_value = {1, 0},
178 },
179 },
180 {
181 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
182 .recv_msg =
183 {
184 .src = 2,
185 .msg = resp,
186 .len = sizeof(resp),
187 },
188 },
189 {
190 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
191 .latency =
192 {
193 .it_interval = {0, 0},
194 .it_value = {4, 0},
195 },
196 },
197 };
198 struct pldm_transport_test* test = NULL;
199 struct pldm_transport* ctx;
200 size_t len;
201 void* msg;
202 int rc;
203
204 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
205 ctx = pldm_transport_test_core(test);
206 rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
207 EXPECT_EQ(rc, PLDM_REQUESTER_RECV_FAIL);
208 pldm_transport_test_destroy(test);
209}
Thu Nguyenf56e4dc2023-07-24 10:39:47 +0700210
Thu Nguyenf56e4dc2023-07-24 10:39:47 +0700211TEST(Transport, send_recv_drain_one_unwanted)
212{
213 uint8_t unwanted[] = {0x01, 0x00, 0x01, 0x01};
214 uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
215 uint8_t resp[] = {0x01, 0x00, 0x01, 0x00};
216 const struct pldm_transport_test_descriptor seq[] = {
217 {
218 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
219 .recv_msg =
220 {
221 .src = 2,
222 .msg = unwanted,
223 .len = sizeof(unwanted),
224 },
225 },
226 {
227 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
228 .send_msg =
229 {
230 .dst = 1,
231 .msg = req,
232 .len = sizeof(req),
233 },
234 },
235 {
236 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
237 .recv_msg =
238 {
239 .src = 1,
240 .msg = resp,
241 .len = sizeof(resp),
242 },
243 },
244 };
245 struct pldm_transport_test* test = NULL;
246 struct pldm_transport* ctx;
247 size_t len;
Andrew Jefferydc1edac2023-08-07 21:15:07 +0930248 void* msg = NULL;
Thu Nguyenf56e4dc2023-07-24 10:39:47 +0700249 int rc;
250
251 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
252 ctx = pldm_transport_test_core(test);
253 rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
Andrew Jefferydc1edac2023-08-07 21:15:07 +0930254 ASSERT_EQ(rc, PLDM_REQUESTER_SUCCESS);
Thu Nguyenf56e4dc2023-07-24 10:39:47 +0700255 EXPECT_NE(memcmp(msg, unwanted, len), 0);
256 EXPECT_EQ(memcmp(msg, resp, len), 0);
257 free(msg);
258 pldm_transport_test_destroy(test);
259}
Thu Nguyen16cd5232023-08-23 06:47:19 +0700260
Thu Nguyen16cd5232023-08-23 06:47:19 +0700261TEST(Transport, send_recv_wrong_pldm_type)
262{
263 uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
264 uint8_t resp[] = {0x01, 0x01, 0x01, 0x00};
265 const struct pldm_transport_test_descriptor seq[] = {
266 {
267 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
268 .send_msg =
269 {
270 .dst = 1,
271 .msg = req,
272 .len = sizeof(req),
273 },
274 },
275 {
276 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
277 .latency =
278 {
279 .it_interval = {0, 0},
280 .it_value = {1, 0},
281 },
282 },
283 {
284 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
285 .recv_msg =
286 {
287 .src = 2,
288 .msg = resp,
289 .len = sizeof(resp),
290 },
291 },
292 {
293 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
294 .latency =
295 {
296 .it_interval = {0, 0},
297 .it_value = {4, 0},
298 },
299 },
300 };
301 struct pldm_transport_test* test = NULL;
302 struct pldm_transport* ctx;
303 size_t len;
304 void* msg;
305 int rc;
306
307 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
308 ctx = pldm_transport_test_core(test);
309 rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
310 EXPECT_EQ(rc, PLDM_REQUESTER_RECV_FAIL);
311 pldm_transport_test_destroy(test);
312}
Thu Nguyen16cd5232023-08-23 06:47:19 +0700313
Thu Nguyen16cd5232023-08-23 06:47:19 +0700314TEST(Transport, send_recv_wrong_command_code)
315{
316 uint8_t req[] = {0x81, 0x00, 0x01, 0x01};
317 uint8_t resp[] = {0x01, 0x00, 0x02, 0x00};
318 const struct pldm_transport_test_descriptor seq[] = {
319 {
320 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_SEND,
321 .send_msg =
322 {
323 .dst = 1,
324 .msg = req,
325 .len = sizeof(req),
326 },
327 },
328 {
329 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
330 .latency =
331 {
332 .it_interval = {0, 0},
333 .it_value = {1, 0},
334 },
335 },
336 {
337 .type = PLDM_TRANSPORT_TEST_ELEMENT_MSG_RECV,
338 .recv_msg =
339 {
340 .src = 2,
341 .msg = resp,
342 .len = sizeof(resp),
343 },
344 },
345 {
346 .type = PLDM_TRANSPORT_TEST_ELEMENT_LATENCY,
347 .latency =
348 {
349 .it_interval = {0, 0},
350 .it_value = {4, 0},
351 },
352 },
353 };
354 struct pldm_transport_test* test = NULL;
355 struct pldm_transport* ctx;
356 size_t len;
357 void* msg;
358 int rc;
359
360 EXPECT_EQ(pldm_transport_test_init(&test, seq, ARRAY_SIZE(seq)), 0);
361 ctx = pldm_transport_test_core(test);
362 rc = pldm_transport_send_recv_msg(ctx, 1, req, sizeof(req), &msg, &len);
363 EXPECT_EQ(rc, PLDM_REQUESTER_RECV_FAIL);
364 pldm_transport_test_destroy(test);
365}