1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
3 */
4
5 #include <rte_errno.h>
6 #include <rte_log.h>
7 #include <rte_memory.h>
8 #include <rte_mempool.h>
9 #include <rte_ether.h>
10 #include <rte_security.h>
11 #include <rte_security_driver.h>
12
13 /* Before including rte_test.h file you can define
14 * RTE_TEST_TRACE_FAILURE(_file, _line, _func) macro to better trace/debug test
15 * failures. Mostly useful in development phase.
16 */
17 #ifndef RTE_TEST_TRACE_FAILURE
18 #define RTE_TEST_TRACE_FAILURE(_file, _line, _func) \
19 RTE_LOG(DEBUG, EAL, "in %s:%d %s\n", _file, _line, _func)
20 #endif
21
22 #include <rte_test.h>
23 #include "test.h"
24
25 /**
26 * Security
27 * =======
28 *
29 * Basic unit tests of the librte_security API.
30 *
31 * Structure of the file:
32 * - macros for making tests more readable;
33 * - mockup structures and functions for rte_security_ops;
34 * - test suite and test cases setup and teardown functions;
35 * - tests functions;
36 * - declaration of testcases.
37 */
38
39
40 /**
41 * Macros
42 *
43 * Set of macros for making tests easier to read.
44 */
45
46 /**
47 * Verify condition inside mocked up function.
48 * Mockup function cannot return a test error, so the failure
49 * of assertion increases counter and print logs.
50 * The counter can be verified later to check if test case should fail.
51 *
52 * @param fail_counter fail counter
53 * @param cond condition expected to be true
54 * @param msg printf style formatting string for custom message
55 */
56 #define MOCK_TEST_ASSERT(fail_counter, cond, msg, ...) do { \
57 if (!(cond)) { \
58 fail_counter++; \
59 RTE_LOG(DEBUG, EAL, "Test assert %s line %d failed: " \
60 msg "\n", __func__, __LINE__, \
61 ##__VA_ARGS__); \
62 RTE_TEST_TRACE_FAILURE(__FILE__, __LINE__, __func__); \
63 } \
64 } while (0)
65
66 /**
67 * Verify equality condition inside mocked up function.
68 * Mockup function cannot return a test error, so the failure
69 * of assertion increases counter and print logs.
70 * The counter can be verified later to check if test case should fail.
71 *
72 * @param fail_counter fail counter
73 * @param a first value of comparison
74 * @param b second value of comparison
75 * @param msg printf style formatting string for custom message
76 */
77 #define MOCK_TEST_ASSERT_EQUAL(fail_counter, a, b, msg, ...) \
78 MOCK_TEST_ASSERT(fail_counter, (a) == (b), msg, ##__VA_ARGS__)
79
80 /**
81 * Verify not null condition inside mocked up function.
82 * Mockup function cannot return a test error, so the failure
83 * of assertion increases counter and print logs.
84 * The counter can be verified later to check if test case should fail.
85 *
86 * @param fail_counter fail counter
87 * @param val value expected not to be NULL
88 * @param msg printf style formatting string for custom message
89 */
90 #define MOCK_TEST_ASSERT_NOT_NULL(fail_counter, val, msg, ...) \
91 MOCK_TEST_ASSERT(fail_counter, (val) != NULL, msg, ##__VA_ARGS__)
92
93
94 /**
95 * Verify if parameter of the mocked up function matches expected value.
96 * The expected value is stored in data structure in the field matching
97 * parameter name.
98 *
99 * @param data structure with expected values
100 * @param parameter name of the parameter (both field and parameter name)
101 * @param spec printf style spec for parameter
102 */
103 #define MOCK_TEST_ASSERT_PARAMETER(data, parameter, spec) \
104 MOCK_TEST_ASSERT_EQUAL(data.failed, data.parameter, parameter, \
105 "Expecting parameter %s to be " spec \
106 " but it's " spec, RTE_STR(parameter), \
107 data.parameter, parameter)
108
109 /**
110 * Wrap for MOCK_TEST_ASSERT_PARAMETER macro for pointer type parameters.
111 *
112 * @param data structure with expected values
113 * @param parameter name of the parameter (both field and parameter name)
114 */
115 #define MOCK_TEST_ASSERT_POINTER_PARAMETER(data, parameter) \
116 MOCK_TEST_ASSERT_PARAMETER(data, parameter, "%p")
117
118 /**
119 * Wrap for MOCK_TEST_ASSERT_PARAMETER macro for uint64_t type parameters.
120 *
121 * @param data structure with expected values
122 * @param parameter name of the parameter (both field and parameter name)
123 */
124 #define MOCK_TEST_ASSERT_U64_PARAMETER(data, parameter) \
125 MOCK_TEST_ASSERT_PARAMETER(data, parameter, "%" PRIu64)
126
127 /**
128 * Verify number of calls of the mocked up function
129 * and check if there were any fails during execution.
130 * The fails statistics inside mocked up functions are collected
131 * as "failed" field in mockup structures.
132 *
133 * @param mock_data structure with statistics (called, failed)
134 * @param exp_calls expected number of mockup function calls
135 */
136 #define TEST_ASSERT_MOCK_CALLS(mock_data, exp_calls) do { \
137 TEST_ASSERT_EQUAL(exp_calls, mock_data.called, \
138 "Expecting sub op to be called %d times, " \
139 "but it's called %d times", \
140 exp_calls, mock_data.called); \
141 TEST_ASSERT_EQUAL(0, mock_data.failed, \
142 "Expecting sub op asserts not to fail, " \
143 "but they're failed %d times", \
144 mock_data.failed); \
145 } while (0)
146
147 /**
148 * Assert tested function result match expected value
149 *
150 * @param f_name name of tested function
151 * @param f_ret value returned by the function
152 * @param exp_ret expected returned value
153 * @param fmt printf style format for returned value
154 */
155 #define TEST_ASSERT_MOCK_FUNCTION_CALL_RET(f_name, f_ret, exp_ret, fmt) \
156 TEST_ASSERT_EQUAL(exp_ret, f_ret, "Expecting " RTE_STR(f_name) \
157 " to return " fmt ", but it returned " fmt \
158 "\n", exp_ret, f_ret)
159
160 /**
161 * Assert tested function result is not NULL
162 *
163 * @param f_name name of tested function
164 * @param f_ret value returned by the function
165 */
166 #define TEST_ASSERT_MOCK_FUNCTION_CALL_NOT_NULL(f_name, f_ret) \
167 TEST_ASSERT_NOT_NULL(f_ret, "Expecting " RTE_STR(f_name) \
168 " to return not NULL\n")
169
170 /**
171 * Verify that sess_cnt counter value matches expected
172 *
173 * @param expected_sessions_count expected counter value
174 */
175 #define TEST_ASSERT_SESSION_COUNT(expected_sessions_count) do { \
176 struct security_unittest_params *ut_params = &unittest_params; \
177 TEST_ASSERT_EQUAL(expected_sessions_count, \
178 ut_params->ctx.sess_cnt, \
179 "Expecting session counter to be %u," \
180 " but it's %u", expected_sessions_count, \
181 ut_params->ctx.sess_cnt); \
182 } while (0)
183
184 /**
185 * Verify usage of mempool by checking if number of allocated objects matches
186 * expectations. The mempool is used to manage objects for sessions data.
187 * A single object is acquired from mempool during session_create
188 * and put back in session_destroy.
189 *
190 * @param expected_mempool_usage expected number of used mempool objects
191 */
192 #define TEST_ASSERT_MEMPOOL_USAGE(expected_mempool_usage) do { \
193 struct security_testsuite_params *ts_params = &testsuite_params;\
194 unsigned int mempool_usage; \
195 mempool_usage = rte_mempool_in_use_count( \
196 ts_params->session_mpool); \
197 TEST_ASSERT_EQUAL(expected_mempool_usage, mempool_usage, \
198 "Expecting %u mempool allocations, " \
199 "but there are %u allocated objects", \
200 expected_mempool_usage, mempool_usage); \
201 } while (0)
202
203 /**
204 * Verify usage of mempool by checking if number of allocated objects matches
205 * expectations. The mempool is used to manage objects for sessions priv data.
206 * A single object is acquired from mempool during session_create
207 * and put back in session_destroy.
208 *
209 * @param expected_priv_mp_usage expected number of used priv mp objects
210 */
211 #define TEST_ASSERT_PRIV_MP_USAGE(expected_priv_mp_usage) do { \
212 struct security_testsuite_params *ts_params = &testsuite_params;\
213 unsigned int priv_mp_usage; \
214 priv_mp_usage = rte_mempool_in_use_count( \
215 ts_params->session_priv_mpool); \
216 TEST_ASSERT_EQUAL(expected_priv_mp_usage, priv_mp_usage, \
217 "Expecting %u priv mempool allocations, " \
218 "but there are %u allocated objects", \
219 expected_priv_mp_usage, priv_mp_usage); \
220 } while (0)
221
222 /**
223 * Mockup structures and functions for rte_security_ops;
224 *
225 * Set of structures for controlling mockup functions calls.
226 * Every mockup function X has its corresponding X_data structure
227 * and an instance of that structure X_exp.
228 * Structure contains parameters that a mockup function is expected
229 * to be called with, a value to return (.ret) and 2 statistics:
230 * .called (number of times the mockup function was called)
231 * and .failed (number of assertion fails during mockup function call).
232 *
233 * Mockup functions verify that the parameters they are called with match
234 * expected values. The expected values should be stored in corresponding
235 * structures prior to mockup functions call. Every failure of such
236 * verification increases .failed counter. Every call of mockup function
237 * increases .called counter. Function returns value stored in .ret field
238 * of the structure.
239 * In case of some parameters in some functions the expected value is unknown
240 * and cannot be determined prior to call. Such parameters are stored
241 * in structure and can be compared or analyzed later in test case code.
242 *
243 * Below structures and functions follow the rules just described.
244 * Additional remarks and exceptions are added in comments.
245 */
246
247 /**
248 * session_create mockup
249 *
250 * Verified parameters: device, conf, mp.
251 * Saved, not verified parameters: sess.
252 */
253 static struct mock_session_create_data {
254 void *device;
255 struct rte_security_session_conf *conf;
256 struct rte_security_session *sess;
257 struct rte_mempool *mp;
258 struct rte_mempool *priv_mp;
259
260 int ret;
261
262 int called;
263 int failed;
264 } mock_session_create_exp = {NULL, NULL, NULL, NULL, NULL, 0, 0, 0};
265
266 static int
mock_session_create(void * device,struct rte_security_session_conf * conf,struct rte_security_session * sess,struct rte_mempool * priv_mp)267 mock_session_create(void *device,
268 struct rte_security_session_conf *conf,
269 struct rte_security_session *sess,
270 struct rte_mempool *priv_mp)
271 {
272 void *sess_priv;
273 int ret;
274
275 mock_session_create_exp.called++;
276
277 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_create_exp, device);
278 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_create_exp, conf);
279 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_create_exp, priv_mp);
280
281 if (mock_session_create_exp.ret == 0) {
282 ret = rte_mempool_get(priv_mp, &sess_priv);
283 TEST_ASSERT_EQUAL(0, ret,
284 "priv mempool does not have enough objects");
285
286 set_sec_session_private_data(sess, sess_priv);
287 mock_session_create_exp.sess = sess;
288 }
289
290 return mock_session_create_exp.ret;
291 }
292
293 /**
294 * session_update mockup
295 *
296 * Verified parameters: device, sess, conf.
297 */
298 static struct mock_session_update_data {
299 void *device;
300 struct rte_security_session *sess;
301 struct rte_security_session_conf *conf;
302
303 int ret;
304
305 int called;
306 int failed;
307 } mock_session_update_exp = {NULL, NULL, NULL, 0, 0, 0};
308
309 static int
mock_session_update(void * device,struct rte_security_session * sess,struct rte_security_session_conf * conf)310 mock_session_update(void *device,
311 struct rte_security_session *sess,
312 struct rte_security_session_conf *conf)
313 {
314 mock_session_update_exp.called++;
315
316 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_update_exp, device);
317 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_update_exp, sess);
318 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_update_exp, conf);
319
320 return mock_session_update_exp.ret;
321 }
322
323 /**
324 * session_get_size mockup
325 *
326 * Verified parameters: device.
327 */
328 static struct mock_session_get_size_data {
329 void *device;
330
331 unsigned int ret;
332
333 int called;
334 int failed;
335 } mock_session_get_size_exp = {NULL, 0U, 0, 0};
336
337 static unsigned int
mock_session_get_size(void * device)338 mock_session_get_size(void *device)
339 {
340 mock_session_get_size_exp.called++;
341
342 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_get_size_exp, device);
343
344 return mock_session_get_size_exp.ret;
345 }
346
347 /**
348 * session_stats_get mockup
349 *
350 * Verified parameters: device, sess, stats.
351 */
352 static struct mock_session_stats_get_data {
353 void *device;
354 struct rte_security_session *sess;
355 struct rte_security_stats *stats;
356
357 int ret;
358
359 int called;
360 int failed;
361 } mock_session_stats_get_exp = {NULL, NULL, NULL, 0, 0, 0};
362
363 static int
mock_session_stats_get(void * device,struct rte_security_session * sess,struct rte_security_stats * stats)364 mock_session_stats_get(void *device,
365 struct rte_security_session *sess,
366 struct rte_security_stats *stats)
367 {
368 mock_session_stats_get_exp.called++;
369
370 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_stats_get_exp, device);
371 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_stats_get_exp, sess);
372 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_stats_get_exp, stats);
373
374 return mock_session_stats_get_exp.ret;
375 }
376
377 /**
378 * session_destroy mockup
379 *
380 * Verified parameters: device, sess.
381 */
382 static struct mock_session_destroy_data {
383 void *device;
384 struct rte_security_session *sess;
385
386 int ret;
387
388 int called;
389 int failed;
390 } mock_session_destroy_exp = {NULL, NULL, 0, 0, 0};
391
392 static int
mock_session_destroy(void * device,struct rte_security_session * sess)393 mock_session_destroy(void *device, struct rte_security_session *sess)
394 {
395 void *sess_priv = get_sec_session_private_data(sess);
396
397 mock_session_destroy_exp.called++;
398 if ((mock_session_destroy_exp.ret == 0) && (sess_priv != NULL)) {
399 rte_mempool_put(rte_mempool_from_obj(sess_priv), sess_priv);
400 set_sec_session_private_data(sess, NULL);
401 }
402 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_destroy_exp, device);
403 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_destroy_exp, sess);
404
405 return mock_session_destroy_exp.ret;
406 }
407
408 /**
409 * set_pkt_metadata mockup
410 *
411 * Verified parameters: device, sess, m, params.
412 */
413 static struct mock_set_pkt_metadata_data {
414 void *device;
415 struct rte_security_session *sess;
416 struct rte_mbuf *m;
417 void *params;
418
419 int ret;
420
421 int called;
422 int failed;
423 } mock_set_pkt_metadata_exp = {NULL, NULL, NULL, NULL, 0, 0, 0};
424
425 static int
mock_set_pkt_metadata(void * device,struct rte_security_session * sess,struct rte_mbuf * m,void * params)426 mock_set_pkt_metadata(void *device,
427 struct rte_security_session *sess,
428 struct rte_mbuf *m,
429 void *params)
430 {
431 mock_set_pkt_metadata_exp.called++;
432
433 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_set_pkt_metadata_exp, device);
434 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_set_pkt_metadata_exp, sess);
435 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_set_pkt_metadata_exp, m);
436 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_set_pkt_metadata_exp, params);
437
438 return mock_set_pkt_metadata_exp.ret;
439 }
440
441 /**
442 * get_userdata mockup
443 *
444 * Verified parameters: device, md.
445 * The userdata parameter works as an output parameter, so a passed address
446 * is verified not to be NULL and filled with userdata stored in structure.
447 */
448 static struct mock_get_userdata_data {
449 void *device;
450 uint64_t md;
451 void *userdata;
452
453 int ret;
454
455 int called;
456 int failed;
457 } mock_get_userdata_exp = {NULL, 0UL, NULL, 0, 0, 0};
458
459 static int
mock_get_userdata(void * device,uint64_t md,void ** userdata)460 mock_get_userdata(void *device,
461 uint64_t md,
462 void **userdata)
463 {
464 mock_get_userdata_exp.called++;
465
466 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_get_userdata_exp, device);
467 MOCK_TEST_ASSERT_U64_PARAMETER(mock_get_userdata_exp, md);
468
469 MOCK_TEST_ASSERT_NOT_NULL(mock_get_userdata_exp.failed,
470 userdata,
471 "Expecting parameter userdata not to be NULL but it's %p",
472 userdata);
473 *userdata = mock_get_userdata_exp.userdata;
474
475 return mock_get_userdata_exp.ret;
476 }
477
478 /**
479 * capabilities_get mockup
480 *
481 * Verified parameters: device.
482 */
483 static struct mock_capabilities_get_data {
484 void *device;
485
486 struct rte_security_capability *ret;
487
488 int called;
489 int failed;
490 } mock_capabilities_get_exp = {NULL, NULL, 0, 0};
491
492 static const struct rte_security_capability *
mock_capabilities_get(void * device)493 mock_capabilities_get(void *device)
494 {
495 mock_capabilities_get_exp.called++;
496
497 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_capabilities_get_exp, device);
498
499 return mock_capabilities_get_exp.ret;
500 }
501
502 /**
503 * empty_ops
504 *
505 * is an empty security operations set (all function pointers set to NULL)
506 */
507 struct rte_security_ops empty_ops = { NULL };
508
509 /**
510 * mock_ops
511 *
512 * is a security operations set using mockup functions
513 */
514 struct rte_security_ops mock_ops = {
515 .session_create = mock_session_create,
516 .session_update = mock_session_update,
517 .session_get_size = mock_session_get_size,
518 .session_stats_get = mock_session_stats_get,
519 .session_destroy = mock_session_destroy,
520 .set_pkt_metadata = mock_set_pkt_metadata,
521 .get_userdata = mock_get_userdata,
522 .capabilities_get = mock_capabilities_get,
523 };
524
525
526 /**
527 * Test suite and test cases setup and teardown functions.
528 */
529
530 /**
531 * struct security_testsuite_params defines parameters initialized once
532 * for whole tests suite.
533 * Currently the only stored parameter is session_mpool a mempool created
534 * once in testsuite_setup and released in testsuite_teardown.
535 * The instance of this structure is stored in testsuite_params variable.
536 */
537 static struct security_testsuite_params {
538 struct rte_mempool *session_mpool;
539 struct rte_mempool *session_priv_mpool;
540 } testsuite_params = { NULL };
541
542 /**
543 * struct security_unittest_params defines parameters initialized
544 * for every test case. The parameters are initialized in ut_setup
545 * or ut_setup_with_session (depending on the testcase)
546 * and released in ut_teardown.
547 * The instance of this structure is stored in unittest_params variable.
548 */
549 static struct security_unittest_params {
550 struct rte_security_ctx ctx;
551 struct rte_security_session_conf conf;
552 struct rte_security_session *sess;
553 } unittest_params = {
554 .ctx = {
555 .device = NULL,
556 .ops = &mock_ops,
557 .sess_cnt = 0,
558 },
559 .sess = NULL,
560 };
561
562 #define SECURITY_TEST_MEMPOOL_NAME "SecurityTestMp"
563 #define SECURITY_TEST_PRIV_MEMPOOL_NAME "SecurityTestPrivMp"
564 #define SECURITY_TEST_MEMPOOL_SIZE 15
565 #define SECURITY_TEST_SESSION_OBJ_SZ sizeof(struct rte_security_session)
566 #define SECURITY_TEST_SESSION_PRIV_OBJ_SZ 64
567
568 /**
569 * testsuite_setup initializes whole test suite parameters.
570 * It creates a new mempool used in all test cases
571 * and verifies if it properly created.
572 */
573 static int
testsuite_setup(void)574 testsuite_setup(void)
575 {
576 struct security_testsuite_params *ts_params = &testsuite_params;
577 ts_params->session_mpool = rte_mempool_create(
578 SECURITY_TEST_MEMPOOL_NAME,
579 SECURITY_TEST_MEMPOOL_SIZE,
580 SECURITY_TEST_SESSION_OBJ_SZ,
581 0, 0, NULL, NULL, NULL, NULL,
582 SOCKET_ID_ANY, 0);
583 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
584 "Cannot create mempool %s\n", rte_strerror(rte_errno));
585
586 ts_params->session_priv_mpool = rte_mempool_create(
587 SECURITY_TEST_PRIV_MEMPOOL_NAME,
588 SECURITY_TEST_MEMPOOL_SIZE,
589 SECURITY_TEST_SESSION_PRIV_OBJ_SZ,
590 0, 0, NULL, NULL, NULL, NULL,
591 SOCKET_ID_ANY, 0);
592 if (ts_params->session_priv_mpool == NULL) {
593 RTE_LOG(ERR, USER1, "TestCase %s() line %d failed (null): "
594 "Cannot create priv mempool %s\n",
595 __func__, __LINE__, rte_strerror(rte_errno));
596 rte_mempool_free(ts_params->session_mpool);
597 ts_params->session_mpool = NULL;
598 return TEST_FAILED;
599 }
600
601 return TEST_SUCCESS;
602 }
603
604 /**
605 * testsuite_teardown releases test suite wide parameters.
606 */
607 static void
testsuite_teardown(void)608 testsuite_teardown(void)
609 {
610 struct security_testsuite_params *ts_params = &testsuite_params;
611 if (ts_params->session_mpool) {
612 rte_mempool_free(ts_params->session_mpool);
613 ts_params->session_mpool = NULL;
614 }
615 if (ts_params->session_priv_mpool) {
616 rte_mempool_free(ts_params->session_priv_mpool);
617 ts_params->session_priv_mpool = NULL;
618 }
619 }
620
621 /**
622 * ut_setup initializes test case parameters to default values.
623 * It resets also any .called and .failed statistics of mockup functions
624 * usage.
625 */
626 static int
ut_setup(void)627 ut_setup(void)
628 {
629 struct security_unittest_params *ut_params = &unittest_params;
630 ut_params->ctx.device = NULL;
631 ut_params->ctx.ops = &mock_ops;
632 ut_params->ctx.sess_cnt = 0;
633 ut_params->sess = NULL;
634
635 mock_session_create_exp.called = 0;
636 mock_session_update_exp.called = 0;
637 mock_session_get_size_exp.called = 0;
638 mock_session_stats_get_exp.called = 0;
639 mock_session_destroy_exp.called = 0;
640 mock_set_pkt_metadata_exp.called = 0;
641 mock_get_userdata_exp.called = 0;
642 mock_capabilities_get_exp.called = 0;
643
644 mock_session_create_exp.failed = 0;
645 mock_session_update_exp.failed = 0;
646 mock_session_get_size_exp.failed = 0;
647 mock_session_stats_get_exp.failed = 0;
648 mock_session_destroy_exp.failed = 0;
649 mock_set_pkt_metadata_exp.failed = 0;
650 mock_get_userdata_exp.failed = 0;
651 mock_capabilities_get_exp.failed = 0;
652
653 return TEST_SUCCESS;
654 }
655
656 /**
657 * destroy_session_with_check is a helper function releasing session
658 * created with rte_security_session_create and stored in test case parameters.
659 * It's used both to release sessions created in test cases' bodies
660 * which are assigned to ut_params->sess
661 * as well as sessions created in ut_setup_with_session.
662 */
663 static int
destroy_session_with_check(void)664 destroy_session_with_check(void)
665 {
666 struct security_unittest_params *ut_params = &unittest_params;
667 if (ut_params->sess != NULL) {
668 /* Assure that mockup function for destroy operation is set. */
669 ut_params->ctx.ops = &mock_ops;
670
671 mock_session_destroy_exp.device = NULL;
672 mock_session_destroy_exp.sess = ut_params->sess;
673 mock_session_destroy_exp.ret = 0;
674 mock_session_destroy_exp.called = 0;
675 mock_session_destroy_exp.failed = 0;
676
677 int ret = rte_security_session_destroy(&ut_params->ctx,
678 ut_params->sess);
679 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
680 ret, 0, "%d");
681 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 1);
682
683 ut_params->sess = NULL;
684 }
685 return TEST_SUCCESS;
686 }
687
688 /**
689 * ut_teardown releases test case parameters.
690 */
691 static void
ut_teardown(void)692 ut_teardown(void)
693 {
694 destroy_session_with_check();
695 }
696
697 /**
698 * ut_setup_with_session initializes test case parameters by
699 * - calling standard ut_setup,
700 * - creating a session that can be used in test case.
701 */
702 static int
ut_setup_with_session(void)703 ut_setup_with_session(void)
704 {
705 struct security_unittest_params *ut_params = &unittest_params;
706 struct security_testsuite_params *ts_params = &testsuite_params;
707 struct rte_security_session *sess;
708
709 int ret = ut_setup();
710 if (ret != TEST_SUCCESS)
711 return ret;
712
713 mock_session_create_exp.device = NULL;
714 mock_session_create_exp.conf = &ut_params->conf;
715 mock_session_create_exp.mp = ts_params->session_mpool;
716 mock_session_create_exp.priv_mp = ts_params->session_priv_mpool;
717 mock_session_create_exp.ret = 0;
718
719 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
720 ts_params->session_mpool,
721 ts_params->session_priv_mpool);
722 TEST_ASSERT_MOCK_FUNCTION_CALL_NOT_NULL(rte_security_session_create,
723 sess);
724 TEST_ASSERT_EQUAL(sess, mock_session_create_exp.sess,
725 "Expecting session_create to be called with %p sess"
726 " parameter, but it's called %p sess parameter",
727 sess, mock_session_create_exp.sess);
728 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 1);
729
730 /*
731 * Store created session in test case parameters, so it can be released
732 * after test case in ut_teardown by destroy_session_with_check.
733 */
734 ut_params->sess = sess;
735
736 return TEST_SUCCESS;
737 }
738
739
740 /**
741 * Test functions
742 *
743 * Each test function is related to a single test case.
744 * They are arranged by tested rte_security API function
745 * and by rte_security execution paths sequence in code.
746 */
747
748 /**
749 * rte_security_session_create tests
750 */
751
752 /**
753 * Test execution of rte_security_session_create with NULL instance
754 */
755 static int
test_session_create_inv_context(void)756 test_session_create_inv_context(void)
757 {
758 struct security_testsuite_params *ts_params = &testsuite_params;
759 struct security_unittest_params *ut_params = &unittest_params;
760 struct rte_security_session *sess;
761
762 sess = rte_security_session_create(NULL, &ut_params->conf,
763 ts_params->session_mpool,
764 ts_params->session_priv_mpool);
765 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
766 sess, NULL, "%p");
767 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
768 TEST_ASSERT_MEMPOOL_USAGE(0);
769 TEST_ASSERT_PRIV_MP_USAGE(0);
770 TEST_ASSERT_SESSION_COUNT(0);
771
772 return TEST_SUCCESS;
773 }
774
775 /**
776 * Test execution of rte_security_session_create with invalid
777 * security operations structure (NULL)
778 */
779 static int
test_session_create_inv_context_ops(void)780 test_session_create_inv_context_ops(void)
781 {
782 struct security_testsuite_params *ts_params = &testsuite_params;
783 struct security_unittest_params *ut_params = &unittest_params;
784 struct rte_security_session *sess;
785
786 ut_params->ctx.ops = NULL;
787
788 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
789 ts_params->session_mpool,
790 ts_params->session_priv_mpool);
791 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
792 sess, NULL, "%p");
793 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
794 TEST_ASSERT_MEMPOOL_USAGE(0);
795 TEST_ASSERT_PRIV_MP_USAGE(0);
796 TEST_ASSERT_SESSION_COUNT(0);
797
798 return TEST_SUCCESS;
799 }
800
801 /**
802 * Test execution of rte_security_session_create with empty
803 * security operations
804 */
805 static int
test_session_create_inv_context_ops_fun(void)806 test_session_create_inv_context_ops_fun(void)
807 {
808 struct security_testsuite_params *ts_params = &testsuite_params;
809 struct security_unittest_params *ut_params = &unittest_params;
810 struct rte_security_session *sess;
811
812 ut_params->ctx.ops = &empty_ops;
813
814 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
815 ts_params->session_mpool,
816 ts_params->session_priv_mpool);
817 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
818 sess, NULL, "%p");
819 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
820 TEST_ASSERT_MEMPOOL_USAGE(0);
821 TEST_ASSERT_PRIV_MP_USAGE(0);
822 TEST_ASSERT_SESSION_COUNT(0);
823
824 return TEST_SUCCESS;
825 }
826
827 /**
828 * Test execution of rte_security_session_create with NULL conf parameter
829 */
830 static int
test_session_create_inv_configuration(void)831 test_session_create_inv_configuration(void)
832 {
833 struct security_testsuite_params *ts_params = &testsuite_params;
834 struct security_unittest_params *ut_params = &unittest_params;
835 struct rte_security_session *sess;
836
837 sess = rte_security_session_create(&ut_params->ctx, NULL,
838 ts_params->session_mpool,
839 ts_params->session_priv_mpool);
840 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
841 sess, NULL, "%p");
842 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
843 TEST_ASSERT_MEMPOOL_USAGE(0);
844 TEST_ASSERT_PRIV_MP_USAGE(0);
845 TEST_ASSERT_SESSION_COUNT(0);
846
847 return TEST_SUCCESS;
848 }
849
850 /**
851 * Test execution of rte_security_session_create with NULL session
852 * mempool
853 */
854 static int
test_session_create_inv_mempool(void)855 test_session_create_inv_mempool(void)
856 {
857 struct security_unittest_params *ut_params = &unittest_params;
858 struct security_testsuite_params *ts_params = &testsuite_params;
859 struct rte_security_session *sess;
860
861 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
862 NULL, ts_params->session_priv_mpool);
863 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
864 sess, NULL, "%p");
865 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
866 TEST_ASSERT_MEMPOOL_USAGE(0);
867 TEST_ASSERT_PRIV_MP_USAGE(0);
868 TEST_ASSERT_SESSION_COUNT(0);
869
870 return TEST_SUCCESS;
871 }
872
873 /**
874 * Test execution of rte_security_session_create with NULL session
875 * priv mempool
876 */
877 static int
test_session_create_inv_sess_priv_mempool(void)878 test_session_create_inv_sess_priv_mempool(void)
879 {
880 struct security_unittest_params *ut_params = &unittest_params;
881 struct security_testsuite_params *ts_params = &testsuite_params;
882 struct rte_security_session *sess;
883
884 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
885 ts_params->session_mpool, NULL);
886 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
887 sess, NULL, "%p");
888 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
889 TEST_ASSERT_MEMPOOL_USAGE(0);
890 TEST_ASSERT_PRIV_MP_USAGE(0);
891 TEST_ASSERT_SESSION_COUNT(0);
892
893 return TEST_SUCCESS;
894 }
895
896 /**
897 * Test execution of rte_security_session_create in case when mempool
898 * is fully used and no object can be got from it
899 */
900 static int
test_session_create_mempool_empty(void)901 test_session_create_mempool_empty(void)
902 {
903 struct security_testsuite_params *ts_params = &testsuite_params;
904 struct security_unittest_params *ut_params = &unittest_params;
905 struct rte_security_session *tmp[SECURITY_TEST_MEMPOOL_SIZE];
906 void *tmp1[SECURITY_TEST_MEMPOOL_SIZE];
907 struct rte_security_session *sess;
908
909 /* Get all available objects from mempool. */
910 int i, ret;
911 for (i = 0; i < SECURITY_TEST_MEMPOOL_SIZE; ++i) {
912 ret = rte_mempool_get(ts_params->session_mpool,
913 (void **)(&tmp[i]));
914 TEST_ASSERT_EQUAL(0, ret,
915 "Expect getting %d object from mempool"
916 " to succeed", i);
917 ret = rte_mempool_get(ts_params->session_priv_mpool,
918 (void **)(&tmp1[i]));
919 TEST_ASSERT_EQUAL(0, ret,
920 "Expect getting %d object from priv mempool"
921 " to succeed", i);
922 }
923 TEST_ASSERT_MEMPOOL_USAGE(SECURITY_TEST_MEMPOOL_SIZE);
924 TEST_ASSERT_PRIV_MP_USAGE(SECURITY_TEST_MEMPOOL_SIZE);
925
926 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
927 ts_params->session_mpool,
928 ts_params->session_priv_mpool);
929 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
930 sess, NULL, "%p");
931 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
932 TEST_ASSERT_MEMPOOL_USAGE(SECURITY_TEST_MEMPOOL_SIZE);
933 TEST_ASSERT_PRIV_MP_USAGE(SECURITY_TEST_MEMPOOL_SIZE);
934 TEST_ASSERT_SESSION_COUNT(0);
935
936 /* Put objects back to the pool. */
937 for (i = 0; i < SECURITY_TEST_MEMPOOL_SIZE; ++i) {
938 rte_mempool_put(ts_params->session_mpool,
939 (void *)(tmp[i]));
940 rte_mempool_put(ts_params->session_priv_mpool,
941 (tmp1[i]));
942 }
943 TEST_ASSERT_MEMPOOL_USAGE(0);
944 TEST_ASSERT_PRIV_MP_USAGE(0);
945
946 return TEST_SUCCESS;
947 }
948
949 /**
950 * Test execution of rte_security_session_create when session_create
951 * security operation fails
952 */
953 static int
test_session_create_ops_failure(void)954 test_session_create_ops_failure(void)
955 {
956 struct security_testsuite_params *ts_params = &testsuite_params;
957 struct security_unittest_params *ut_params = &unittest_params;
958 struct rte_security_session *sess;
959
960 mock_session_create_exp.device = NULL;
961 mock_session_create_exp.conf = &ut_params->conf;
962 mock_session_create_exp.mp = ts_params->session_mpool;
963 mock_session_create_exp.priv_mp = ts_params->session_priv_mpool;
964 mock_session_create_exp.ret = -1; /* Return failure status. */
965
966 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
967 ts_params->session_mpool,
968 ts_params->session_priv_mpool);
969 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
970 sess, NULL, "%p");
971 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 1);
972 TEST_ASSERT_MEMPOOL_USAGE(0);
973 TEST_ASSERT_PRIV_MP_USAGE(0);
974 TEST_ASSERT_SESSION_COUNT(0);
975
976 return TEST_SUCCESS;
977 }
978
979 /**
980 * Test execution of rte_security_session_create in successful execution path
981 */
982 static int
test_session_create_success(void)983 test_session_create_success(void)
984 {
985 struct security_testsuite_params *ts_params = &testsuite_params;
986 struct security_unittest_params *ut_params = &unittest_params;
987 struct rte_security_session *sess;
988
989 mock_session_create_exp.device = NULL;
990 mock_session_create_exp.conf = &ut_params->conf;
991 mock_session_create_exp.mp = ts_params->session_mpool;
992 mock_session_create_exp.priv_mp = ts_params->session_priv_mpool;
993 mock_session_create_exp.ret = 0; /* Return success status. */
994
995 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
996 ts_params->session_mpool,
997 ts_params->session_priv_mpool);
998 TEST_ASSERT_MOCK_FUNCTION_CALL_NOT_NULL(rte_security_session_create,
999 sess);
1000 TEST_ASSERT_EQUAL(sess, mock_session_create_exp.sess,
1001 "Expecting session_create to be called with %p sess"
1002 " parameter, but it's called %p sess parameter",
1003 sess, mock_session_create_exp.sess);
1004 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 1);
1005 TEST_ASSERT_MEMPOOL_USAGE(1);
1006 TEST_ASSERT_PRIV_MP_USAGE(1);
1007 TEST_ASSERT_SESSION_COUNT(1);
1008
1009 /*
1010 * Store created session in test case parameters, so it can be released
1011 * after test case in ut_teardown by destroy_session_with_check.
1012 */
1013 ut_params->sess = sess;
1014
1015 return TEST_SUCCESS;
1016 }
1017
1018
1019 /**
1020 * rte_security_session_update tests
1021 */
1022
1023 /**
1024 * Test execution of rte_security_session_update with NULL instance
1025 */
1026 static int
test_session_update_inv_context(void)1027 test_session_update_inv_context(void)
1028 {
1029 struct security_unittest_params *ut_params = &unittest_params;
1030
1031 int ret = rte_security_session_update(NULL, ut_params->sess,
1032 &ut_params->conf);
1033 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1034 ret, -EINVAL, "%d");
1035 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
1036
1037 return TEST_SUCCESS;
1038 }
1039
1040 /**
1041 * Test execution of rte_security_session_update with invalid
1042 * security operations structure (NULL)
1043 */
1044 static int
test_session_update_inv_context_ops(void)1045 test_session_update_inv_context_ops(void)
1046 {
1047 struct security_unittest_params *ut_params = &unittest_params;
1048 ut_params->ctx.ops = NULL;
1049
1050 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
1051 &ut_params->conf);
1052 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1053 ret, -EINVAL, "%d");
1054 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
1055
1056 return TEST_SUCCESS;
1057 }
1058
1059 /**
1060 * Test execution of rte_security_session_update with empty
1061 * security operations
1062 */
1063 static int
test_session_update_inv_context_ops_fun(void)1064 test_session_update_inv_context_ops_fun(void)
1065 {
1066 struct security_unittest_params *ut_params = &unittest_params;
1067 ut_params->ctx.ops = &empty_ops;
1068
1069 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
1070 &ut_params->conf);
1071 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1072 ret, -ENOTSUP, "%d");
1073 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
1074
1075 return TEST_SUCCESS;
1076 }
1077
1078 /**
1079 * Test execution of rte_security_session_update with NULL conf parameter
1080 */
1081 static int
test_session_update_inv_configuration(void)1082 test_session_update_inv_configuration(void)
1083 {
1084 struct security_unittest_params *ut_params = &unittest_params;
1085
1086 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
1087 NULL);
1088 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1089 ret, -EINVAL, "%d");
1090 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
1091
1092 return TEST_SUCCESS;
1093 }
1094
1095 /**
1096 * Test execution of rte_security_session_update with NULL sess parameter
1097 */
1098 static int
test_session_update_inv_session(void)1099 test_session_update_inv_session(void)
1100 {
1101 struct security_unittest_params *ut_params = &unittest_params;
1102
1103 int ret = rte_security_session_update(&ut_params->ctx, NULL,
1104 &ut_params->conf);
1105 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1106 ret, -EINVAL, "%d");
1107 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
1108
1109 return TEST_SUCCESS;
1110 }
1111
1112 /**
1113 * Test execution of rte_security_session_update when session_update
1114 * security operation fails
1115 */
1116 static int
test_session_update_ops_failure(void)1117 test_session_update_ops_failure(void)
1118 {
1119 struct security_unittest_params *ut_params = &unittest_params;
1120
1121 mock_session_update_exp.device = NULL;
1122 mock_session_update_exp.sess = ut_params->sess;
1123 mock_session_update_exp.conf = &ut_params->conf;
1124 mock_session_update_exp.ret = -1; /* Return failure status. */
1125
1126 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
1127 &ut_params->conf);
1128 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1129 ret, -1, "%d");
1130 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 1);
1131
1132 return TEST_SUCCESS;
1133 }
1134
1135 /**
1136 * Test execution of rte_security_session_update in successful execution path
1137 */
1138 static int
test_session_update_success(void)1139 test_session_update_success(void)
1140 {
1141 struct security_unittest_params *ut_params = &unittest_params;
1142
1143 mock_session_update_exp.device = NULL;
1144 mock_session_update_exp.sess = ut_params->sess;
1145 mock_session_update_exp.conf = &ut_params->conf;
1146 mock_session_update_exp.ret = 0; /* Return success status. */
1147
1148 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
1149 &ut_params->conf);
1150 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
1151 ret, 0, "%d");
1152 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 1);
1153
1154 return TEST_SUCCESS;
1155 }
1156
1157
1158 /**
1159 * rte_security_session_get_size tests
1160 */
1161
1162 /**
1163 * Test execution of rte_security_session_get_size with NULL instance
1164 */
1165 static int
test_session_get_size_inv_context(void)1166 test_session_get_size_inv_context(void)
1167 {
1168 unsigned int ret = rte_security_session_get_size(NULL);
1169 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
1170 ret, 0, "%u");
1171 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 0);
1172
1173 return TEST_SUCCESS;
1174 }
1175
1176 /**
1177 * Test execution of rte_security_session_get_size with invalid
1178 * security operations structure (NULL)
1179 */
1180 static int
test_session_get_size_inv_context_ops(void)1181 test_session_get_size_inv_context_ops(void)
1182 {
1183 struct security_unittest_params *ut_params = &unittest_params;
1184 ut_params->ctx.ops = NULL;
1185
1186 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
1187 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
1188 ret, 0, "%u");
1189 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 0);
1190
1191 return TEST_SUCCESS;
1192 }
1193
1194 /**
1195 * Test execution of rte_security_session_get_size with empty
1196 * security operations
1197 */
1198 static int
test_session_get_size_inv_context_ops_fun(void)1199 test_session_get_size_inv_context_ops_fun(void)
1200 {
1201 struct security_unittest_params *ut_params = &unittest_params;
1202 ut_params->ctx.ops = &empty_ops;
1203
1204 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
1205 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
1206 ret, 0, "%u");
1207 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 0);
1208
1209 return TEST_SUCCESS;
1210 }
1211
1212 /**
1213 * Test execution of rte_security_session_get_size when session_get_size
1214 * security operation fails
1215 */
1216 static int
test_session_get_size_ops_failure(void)1217 test_session_get_size_ops_failure(void)
1218 {
1219 struct security_unittest_params *ut_params = &unittest_params;
1220
1221 mock_session_get_size_exp.device = NULL;
1222 mock_session_get_size_exp.ret = 0;
1223
1224 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
1225 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
1226 ret, 0, "%u");
1227 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 1);
1228
1229 return TEST_SUCCESS;
1230 }
1231
1232 /**
1233 * Test execution of rte_security_session_get_size in successful execution path
1234 */
1235 static int
test_session_get_size_success(void)1236 test_session_get_size_success(void)
1237 {
1238 struct security_unittest_params *ut_params = &unittest_params;
1239
1240 mock_session_get_size_exp.device = NULL;
1241 mock_session_get_size_exp.ret = 1024;
1242
1243 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
1244 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
1245 ret, 1024U, "%u");
1246 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 1);
1247
1248 return TEST_SUCCESS;
1249 }
1250
1251
1252 /**
1253 * rte_security_session_stats_get tests
1254 */
1255
1256 /**
1257 * Test execution of rte_security_session_stats_get with NULL instance
1258 */
1259 static int
test_session_stats_get_inv_context(void)1260 test_session_stats_get_inv_context(void)
1261 {
1262 struct security_unittest_params *ut_params = &unittest_params;
1263 struct rte_security_stats stats;
1264
1265 int ret = rte_security_session_stats_get(NULL, ut_params->sess, &stats);
1266 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_stats_get,
1267 ret, -EINVAL, "%d");
1268 TEST_ASSERT_MOCK_CALLS(mock_session_stats_get_exp, 0);
1269
1270 return TEST_SUCCESS;
1271 }
1272
1273 /**
1274 * Test execution of rte_security_session_stats_get with invalid
1275 * security operations structure (NULL)
1276 */
1277 static int
test_session_stats_get_inv_context_ops(void)1278 test_session_stats_get_inv_context_ops(void)
1279 {
1280 struct security_unittest_params *ut_params = &unittest_params;
1281 struct rte_security_stats stats;
1282 ut_params->ctx.ops = NULL;
1283
1284 int ret = rte_security_session_stats_get(&ut_params->ctx,
1285 ut_params->sess, &stats);
1286 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_stats_get,
1287 ret, -EINVAL, "%d");
1288 TEST_ASSERT_MOCK_CALLS(mock_session_stats_get_exp, 0);
1289
1290 return TEST_SUCCESS;
1291 }
1292
1293 /**
1294 * Test execution of rte_security_session_stats_get with empty
1295 * security operations
1296 */
1297 static int
test_session_stats_get_inv_context_ops_fun(void)1298 test_session_stats_get_inv_context_ops_fun(void)
1299 {
1300 struct security_unittest_params *ut_params = &unittest_params;
1301 struct rte_security_stats stats;
1302 ut_params->ctx.ops = &empty_ops;
1303
1304 int ret = rte_security_session_stats_get(&ut_params->ctx,
1305 ut_params->sess, &stats);
1306 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_stats_get,
1307 ret, -ENOTSUP, "%d");
1308 TEST_ASSERT_MOCK_CALLS(mock_session_stats_get_exp, 0);
1309
1310 return TEST_SUCCESS;
1311 }
1312
1313 /**
1314 * Test execution of rte_security_session_stats_get with NULL stats parameter
1315 */
1316 static int
test_session_stats_get_inv_stats(void)1317 test_session_stats_get_inv_stats(void)
1318 {
1319 struct security_unittest_params *ut_params = &unittest_params;
1320
1321 int ret = rte_security_session_stats_get(&ut_params->ctx,
1322 ut_params->sess, NULL);
1323 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_stats_get,
1324 ret, -EINVAL, "%d");
1325 TEST_ASSERT_MOCK_CALLS(mock_session_stats_get_exp, 0);
1326
1327 return TEST_SUCCESS;
1328 }
1329
1330 /**
1331 * Test execution of rte_security_session_stats_get when session_stats_get
1332 * security operation fails
1333 */
1334 static int
test_session_stats_get_ops_failure(void)1335 test_session_stats_get_ops_failure(void)
1336 {
1337 struct security_unittest_params *ut_params = &unittest_params;
1338 struct rte_security_stats stats;
1339
1340 mock_session_stats_get_exp.device = NULL;
1341 mock_session_stats_get_exp.sess = ut_params->sess;
1342 mock_session_stats_get_exp.stats = &stats;
1343 mock_session_stats_get_exp.ret = -1;
1344
1345 int ret = rte_security_session_stats_get(&ut_params->ctx,
1346 ut_params->sess, &stats);
1347 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_stats_get,
1348 ret, -1, "%d");
1349 TEST_ASSERT_MOCK_CALLS(mock_session_stats_get_exp, 1);
1350
1351 return TEST_SUCCESS;
1352 }
1353
1354 /**
1355 * Test execution of rte_security_session_stats_get in successful execution
1356 * path
1357 */
1358 static int
test_session_stats_get_success(void)1359 test_session_stats_get_success(void)
1360 {
1361 struct security_unittest_params *ut_params = &unittest_params;
1362 struct rte_security_stats stats;
1363
1364 mock_session_stats_get_exp.device = NULL;
1365 mock_session_stats_get_exp.sess = ut_params->sess;
1366 mock_session_stats_get_exp.stats = &stats;
1367 mock_session_stats_get_exp.ret = 0;
1368
1369 int ret = rte_security_session_stats_get(&ut_params->ctx,
1370 ut_params->sess, &stats);
1371 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_stats_get,
1372 ret, 0, "%d");
1373 TEST_ASSERT_MOCK_CALLS(mock_session_stats_get_exp, 1);
1374
1375 return TEST_SUCCESS;
1376 }
1377
1378
1379 /**
1380 * rte_security_session_destroy tests
1381 */
1382
1383 /**
1384 * Test execution of rte_security_session_destroy with NULL instance
1385 */
1386 static int
test_session_destroy_inv_context(void)1387 test_session_destroy_inv_context(void)
1388 {
1389 struct security_unittest_params *ut_params = &unittest_params;
1390
1391 TEST_ASSERT_MEMPOOL_USAGE(1);
1392 TEST_ASSERT_PRIV_MP_USAGE(1);
1393 TEST_ASSERT_SESSION_COUNT(1);
1394
1395 int ret = rte_security_session_destroy(NULL, ut_params->sess);
1396 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
1397 ret, -EINVAL, "%d");
1398 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 0);
1399 TEST_ASSERT_MEMPOOL_USAGE(1);
1400 TEST_ASSERT_PRIV_MP_USAGE(1);
1401 TEST_ASSERT_SESSION_COUNT(1);
1402
1403 return TEST_SUCCESS;
1404 }
1405
1406 /**
1407 * Test execution of rte_security_session_destroy with invalid
1408 * security operations structure (NULL)
1409 */
1410 static int
test_session_destroy_inv_context_ops(void)1411 test_session_destroy_inv_context_ops(void)
1412 {
1413 struct security_unittest_params *ut_params = &unittest_params;
1414 ut_params->ctx.ops = NULL;
1415
1416 TEST_ASSERT_MEMPOOL_USAGE(1);
1417 TEST_ASSERT_PRIV_MP_USAGE(1);
1418 TEST_ASSERT_SESSION_COUNT(1);
1419
1420 int ret = rte_security_session_destroy(&ut_params->ctx,
1421 ut_params->sess);
1422 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
1423 ret, -EINVAL, "%d");
1424 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 0);
1425 TEST_ASSERT_MEMPOOL_USAGE(1);
1426 TEST_ASSERT_PRIV_MP_USAGE(1);
1427 TEST_ASSERT_SESSION_COUNT(1);
1428
1429 return TEST_SUCCESS;
1430 }
1431
1432 /**
1433 * Test execution of rte_security_session_destroy with empty
1434 * security operations
1435 */
1436 static int
test_session_destroy_inv_context_ops_fun(void)1437 test_session_destroy_inv_context_ops_fun(void)
1438 {
1439 struct security_unittest_params *ut_params = &unittest_params;
1440 ut_params->ctx.ops = &empty_ops;
1441
1442 TEST_ASSERT_MEMPOOL_USAGE(1);
1443 TEST_ASSERT_PRIV_MP_USAGE(1);
1444 TEST_ASSERT_SESSION_COUNT(1);
1445
1446 int ret = rte_security_session_destroy(&ut_params->ctx,
1447 ut_params->sess);
1448 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
1449 ret, -ENOTSUP, "%d");
1450 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 0);
1451 TEST_ASSERT_MEMPOOL_USAGE(1);
1452 TEST_ASSERT_PRIV_MP_USAGE(1);
1453 TEST_ASSERT_SESSION_COUNT(1);
1454
1455 return TEST_SUCCESS;
1456 }
1457
1458 /**
1459 * Test execution of rte_security_session_destroy with NULL sess parameter
1460 */
1461 static int
test_session_destroy_inv_session(void)1462 test_session_destroy_inv_session(void)
1463 {
1464 struct security_unittest_params *ut_params = &unittest_params;
1465
1466 TEST_ASSERT_MEMPOOL_USAGE(1);
1467 TEST_ASSERT_PRIV_MP_USAGE(1);
1468 TEST_ASSERT_SESSION_COUNT(1);
1469
1470 int ret = rte_security_session_destroy(&ut_params->ctx, NULL);
1471 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
1472 ret, -EINVAL, "%d");
1473 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 0);
1474 TEST_ASSERT_MEMPOOL_USAGE(1);
1475 TEST_ASSERT_PRIV_MP_USAGE(1);
1476 TEST_ASSERT_SESSION_COUNT(1);
1477
1478 return TEST_SUCCESS;
1479 }
1480
1481 /**
1482 * Test execution of rte_security_session_destroy when session_destroy
1483 * security operation fails
1484 */
1485 static int
test_session_destroy_ops_failure(void)1486 test_session_destroy_ops_failure(void)
1487 {
1488 struct security_unittest_params *ut_params = &unittest_params;
1489
1490 mock_session_destroy_exp.device = NULL;
1491 mock_session_destroy_exp.sess = ut_params->sess;
1492 mock_session_destroy_exp.ret = -1;
1493
1494 TEST_ASSERT_MEMPOOL_USAGE(1);
1495 TEST_ASSERT_PRIV_MP_USAGE(1);
1496 TEST_ASSERT_SESSION_COUNT(1);
1497
1498 int ret = rte_security_session_destroy(&ut_params->ctx,
1499 ut_params->sess);
1500 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
1501 ret, -1, "%d");
1502 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 1);
1503 TEST_ASSERT_MEMPOOL_USAGE(1);
1504 TEST_ASSERT_PRIV_MP_USAGE(1);
1505 TEST_ASSERT_SESSION_COUNT(1);
1506
1507 return TEST_SUCCESS;
1508 }
1509
1510 /**
1511 * Test execution of rte_security_session_destroy in successful execution path
1512 */
1513 static int
test_session_destroy_success(void)1514 test_session_destroy_success(void)
1515 {
1516 struct security_unittest_params *ut_params = &unittest_params;
1517
1518 mock_session_destroy_exp.device = NULL;
1519 mock_session_destroy_exp.sess = ut_params->sess;
1520 mock_session_destroy_exp.ret = 0;
1521 TEST_ASSERT_MEMPOOL_USAGE(1);
1522 TEST_ASSERT_PRIV_MP_USAGE(1);
1523 TEST_ASSERT_SESSION_COUNT(1);
1524
1525 int ret = rte_security_session_destroy(&ut_params->ctx,
1526 ut_params->sess);
1527 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
1528 ret, 0, "%d");
1529 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 1);
1530 TEST_ASSERT_MEMPOOL_USAGE(0);
1531 TEST_ASSERT_PRIV_MP_USAGE(0);
1532 TEST_ASSERT_SESSION_COUNT(0);
1533
1534 /*
1535 * Remove session from test case parameters, so it won't be destroyed
1536 * during test case teardown.
1537 */
1538 ut_params->sess = NULL;
1539
1540 return TEST_SUCCESS;
1541 }
1542
1543
1544 /**
1545 * rte_security_set_pkt_metadata tests
1546 */
1547
1548 /**
1549 * Test execution of rte_security_set_pkt_metadata with NULL instance
1550 */
1551 static int
test_set_pkt_metadata_inv_context(void)1552 test_set_pkt_metadata_inv_context(void)
1553 {
1554 #ifdef RTE_DEBUG
1555 struct security_unittest_params *ut_params = &unittest_params;
1556 struct rte_mbuf m;
1557 int params;
1558
1559 int ret = rte_security_set_pkt_metadata(NULL, ut_params->sess, &m,
1560 ¶ms);
1561 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_set_pkt_metadata,
1562 ret, -EINVAL, "%d");
1563 TEST_ASSERT_MOCK_CALLS(mock_set_pkt_metadata_exp, 0);
1564
1565 return TEST_SUCCESS;
1566 #else
1567 return TEST_SKIPPED;
1568 #endif
1569 }
1570
1571 /**
1572 * Test execution of rte_security_set_pkt_metadata with invalid
1573 * security operations structure (NULL)
1574 */
1575 static int
test_set_pkt_metadata_inv_context_ops(void)1576 test_set_pkt_metadata_inv_context_ops(void)
1577 {
1578 #ifdef RTE_DEBUG
1579 struct security_unittest_params *ut_params = &unittest_params;
1580 struct rte_mbuf m;
1581 int params;
1582 ut_params->ctx.ops = NULL;
1583
1584 int ret = rte_security_set_pkt_metadata(&ut_params->ctx,
1585 ut_params->sess, &m, ¶ms);
1586 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_set_pkt_metadata,
1587 ret, -EINVAL, "%d");
1588 TEST_ASSERT_MOCK_CALLS(mock_set_pkt_metadata_exp, 0);
1589
1590 return TEST_SUCCESS;
1591 #else
1592 return TEST_SKIPPED;
1593 #endif
1594 }
1595
1596 /**
1597 * Test execution of rte_security_set_pkt_metadata with empty
1598 * security operations
1599 */
1600 static int
test_set_pkt_metadata_inv_context_ops_fun(void)1601 test_set_pkt_metadata_inv_context_ops_fun(void)
1602 {
1603 struct security_unittest_params *ut_params = &unittest_params;
1604 struct rte_mbuf m;
1605 int params;
1606 ut_params->ctx.ops = &empty_ops;
1607
1608 int ret = rte_security_set_pkt_metadata(&ut_params->ctx,
1609 ut_params->sess, &m, ¶ms);
1610 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_set_pkt_metadata,
1611 ret, -ENOTSUP, "%d");
1612 TEST_ASSERT_MOCK_CALLS(mock_set_pkt_metadata_exp, 0);
1613
1614 return TEST_SUCCESS;
1615 }
1616
1617 /**
1618 * Test execution of rte_security_set_pkt_metadata with NULL sess parameter
1619 */
1620 static int
test_set_pkt_metadata_inv_session(void)1621 test_set_pkt_metadata_inv_session(void)
1622 {
1623 #ifdef RTE_DEBUG
1624 struct security_unittest_params *ut_params = &unittest_params;
1625 struct rte_mbuf m;
1626 int params;
1627
1628 int ret = rte_security_set_pkt_metadata(&ut_params->ctx, NULL,
1629 &m, ¶ms);
1630 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_set_pkt_metadata,
1631 ret, -EINVAL, "%d");
1632 TEST_ASSERT_MOCK_CALLS(mock_set_pkt_metadata_exp, 0);
1633
1634 return TEST_SUCCESS;
1635 #else
1636 return TEST_SKIPPED;
1637 #endif
1638 }
1639
1640 /**
1641 * Test execution of rte_security_set_pkt_metadata when set_pkt_metadata
1642 * security operation fails
1643 */
1644 static int
test_set_pkt_metadata_ops_failure(void)1645 test_set_pkt_metadata_ops_failure(void)
1646 {
1647 struct security_unittest_params *ut_params = &unittest_params;
1648 struct rte_mbuf m;
1649 int params;
1650
1651 mock_set_pkt_metadata_exp.device = NULL;
1652 mock_set_pkt_metadata_exp.sess = ut_params->sess;
1653 mock_set_pkt_metadata_exp.m = &m;
1654 mock_set_pkt_metadata_exp.params = ¶ms;
1655 mock_set_pkt_metadata_exp.ret = -1;
1656
1657 int ret = rte_security_set_pkt_metadata(&ut_params->ctx,
1658 ut_params->sess, &m, ¶ms);
1659 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_set_pkt_metadata,
1660 ret, -1, "%d");
1661 TEST_ASSERT_MOCK_CALLS(mock_set_pkt_metadata_exp, 1);
1662
1663 return TEST_SUCCESS;
1664 }
1665
1666 /**
1667 * Test execution of rte_security_set_pkt_metadata in successful execution path
1668 */
1669 static int
test_set_pkt_metadata_success(void)1670 test_set_pkt_metadata_success(void)
1671 {
1672 struct security_unittest_params *ut_params = &unittest_params;
1673 struct rte_mbuf m;
1674 int params;
1675
1676 mock_set_pkt_metadata_exp.device = NULL;
1677 mock_set_pkt_metadata_exp.sess = ut_params->sess;
1678 mock_set_pkt_metadata_exp.m = &m;
1679 mock_set_pkt_metadata_exp.params = ¶ms;
1680 mock_set_pkt_metadata_exp.ret = 0;
1681
1682 int ret = rte_security_set_pkt_metadata(&ut_params->ctx,
1683 ut_params->sess, &m, ¶ms);
1684 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_set_pkt_metadata,
1685 ret, 0, "%d");
1686 TEST_ASSERT_MOCK_CALLS(mock_set_pkt_metadata_exp, 1);
1687
1688 return TEST_SUCCESS;
1689 }
1690
1691
1692 /**
1693 * rte_security_get_userdata tests
1694 */
1695
1696 /**
1697 * Test execution of rte_security_get_userdata with NULL instance
1698 */
1699 static int
test_get_userdata_inv_context(void)1700 test_get_userdata_inv_context(void)
1701 {
1702 #ifdef RTE_DEBUG
1703 uint64_t md = 0xDEADBEEF;
1704
1705 void *ret = rte_security_get_userdata(NULL, md);
1706 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_get_userdata,
1707 ret, NULL, "%p");
1708 TEST_ASSERT_MOCK_CALLS(mock_get_userdata_exp, 0);
1709
1710 return TEST_SUCCESS;
1711 #else
1712 return TEST_SKIPPED;
1713 #endif
1714 }
1715
1716 /**
1717 * Test execution of rte_security_get_userdata with invalid
1718 * security operations structure (NULL)
1719 */
1720 static int
test_get_userdata_inv_context_ops(void)1721 test_get_userdata_inv_context_ops(void)
1722 {
1723 #ifdef RTE_DEBUG
1724 struct security_unittest_params *ut_params = &unittest_params;
1725 uint64_t md = 0xDEADBEEF;
1726 ut_params->ctx.ops = NULL;
1727
1728 void *ret = rte_security_get_userdata(&ut_params->ctx, md);
1729 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_get_userdata,
1730 ret, NULL, "%p");
1731 TEST_ASSERT_MOCK_CALLS(mock_get_userdata_exp, 0);
1732
1733 return TEST_SUCCESS;
1734 #else
1735 return TEST_SKIPPED;
1736 #endif
1737 }
1738
1739 /**
1740 * Test execution of rte_security_get_userdata with empty
1741 * security operations
1742 */
1743 static int
test_get_userdata_inv_context_ops_fun(void)1744 test_get_userdata_inv_context_ops_fun(void)
1745 {
1746 struct security_unittest_params *ut_params = &unittest_params;
1747 uint64_t md = 0xDEADBEEF;
1748 ut_params->ctx.ops = &empty_ops;
1749
1750 void *ret = rte_security_get_userdata(&ut_params->ctx, md);
1751 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_get_userdata,
1752 ret, NULL, "%p");
1753 TEST_ASSERT_MOCK_CALLS(mock_get_userdata_exp, 0);
1754
1755 return TEST_SUCCESS;
1756 }
1757
1758 /**
1759 * Test execution of rte_security_get_userdata when get_userdata
1760 * security operation fails
1761 */
1762 static int
test_get_userdata_ops_failure(void)1763 test_get_userdata_ops_failure(void)
1764 {
1765 struct security_unittest_params *ut_params = &unittest_params;
1766 uint64_t md = 0xDEADBEEF;
1767 void *userdata = (void *)0x7E577E57;
1768
1769 mock_get_userdata_exp.device = NULL;
1770 mock_get_userdata_exp.md = md;
1771 mock_get_userdata_exp.userdata = userdata;
1772 mock_get_userdata_exp.ret = -1;
1773
1774 void *ret = rte_security_get_userdata(&ut_params->ctx, md);
1775 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_get_userdata,
1776 ret, NULL, "%p");
1777 TEST_ASSERT_MOCK_CALLS(mock_get_userdata_exp, 1);
1778
1779 return TEST_SUCCESS;
1780 }
1781
1782 /**
1783 * Test execution of rte_security_get_userdata in successful execution path
1784 */
1785 static int
test_get_userdata_success(void)1786 test_get_userdata_success(void)
1787 {
1788 struct security_unittest_params *ut_params = &unittest_params;
1789 uint64_t md = 0xDEADBEEF;
1790 void *userdata = (void *)0x7E577E57;
1791
1792 mock_get_userdata_exp.device = NULL;
1793 mock_get_userdata_exp.md = md;
1794 mock_get_userdata_exp.userdata = userdata;
1795 mock_get_userdata_exp.ret = 0;
1796
1797 void *ret = rte_security_get_userdata(&ut_params->ctx, md);
1798 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_get_userdata,
1799 ret, userdata, "%p");
1800 TEST_ASSERT_MOCK_CALLS(mock_get_userdata_exp, 1);
1801
1802 return TEST_SUCCESS;
1803 }
1804
1805
1806 /**
1807 * rte_security_capabilities_get tests
1808 */
1809
1810 /**
1811 * Test execution of rte_security_capabilities_get with NULL instance
1812 */
1813 static int
test_capabilities_get_inv_context(void)1814 test_capabilities_get_inv_context(void)
1815 {
1816 const struct rte_security_capability *ret;
1817 ret = rte_security_capabilities_get(NULL);
1818 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capabilities_get,
1819 ret, NULL, "%p");
1820 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1821
1822 return TEST_SUCCESS;
1823 }
1824
1825 /**
1826 * Test execution of rte_security_capabilities_get with invalid
1827 * security operations structure (NULL)
1828 */
1829 static int
test_capabilities_get_inv_context_ops(void)1830 test_capabilities_get_inv_context_ops(void)
1831 {
1832 struct security_unittest_params *ut_params = &unittest_params;
1833 ut_params->ctx.ops = NULL;
1834
1835 const struct rte_security_capability *ret;
1836 ret = rte_security_capabilities_get(&ut_params->ctx);
1837 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capabilities_get,
1838 ret, NULL, "%p");
1839 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1840
1841 return TEST_SUCCESS;
1842 }
1843
1844 /**
1845 * Test execution of rte_security_capabilities_get with empty
1846 * security operations
1847 */
1848 static int
test_capabilities_get_inv_context_ops_fun(void)1849 test_capabilities_get_inv_context_ops_fun(void)
1850 {
1851 struct security_unittest_params *ut_params = &unittest_params;
1852 ut_params->ctx.ops = &empty_ops;
1853
1854 const struct rte_security_capability *ret;
1855 ret = rte_security_capabilities_get(&ut_params->ctx);
1856 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capabilities_get,
1857 ret, NULL, "%p");
1858 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1859
1860 return TEST_SUCCESS;
1861 }
1862
1863 /**
1864 * Test execution of rte_security_capabilities_get when capabilities_get
1865 * security operation fails
1866 */
1867 static int
test_capabilities_get_ops_failure(void)1868 test_capabilities_get_ops_failure(void)
1869 {
1870 struct security_unittest_params *ut_params = &unittest_params;
1871
1872 mock_capabilities_get_exp.device = NULL;
1873 mock_capabilities_get_exp.ret = NULL;
1874
1875 const struct rte_security_capability *ret;
1876 ret = rte_security_capabilities_get(&ut_params->ctx);
1877 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capabilities_get,
1878 ret, NULL, "%p");
1879 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
1880
1881 return TEST_SUCCESS;
1882 }
1883
1884 /**
1885 * Test execution of rte_security_capabilities_get in successful execution path
1886 */
1887 static int
test_capabilities_get_success(void)1888 test_capabilities_get_success(void)
1889 {
1890 struct security_unittest_params *ut_params = &unittest_params;
1891 struct rte_security_capability capabilities;
1892
1893 mock_capabilities_get_exp.device = NULL;
1894 mock_capabilities_get_exp.ret = &capabilities;
1895
1896 const struct rte_security_capability *ret;
1897 ret = rte_security_capabilities_get(&ut_params->ctx);
1898 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capabilities_get,
1899 ret, &capabilities, "%p");
1900 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
1901
1902 return TEST_SUCCESS;
1903 }
1904
1905
1906 /**
1907 * rte_security_capability_get tests
1908 */
1909
1910 /**
1911 * Test execution of rte_security_capability_get with NULL instance
1912 */
1913 static int
test_capability_get_inv_context(void)1914 test_capability_get_inv_context(void)
1915 {
1916 struct rte_security_capability_idx idx;
1917
1918 const struct rte_security_capability *ret;
1919 ret = rte_security_capability_get(NULL, &idx);
1920 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
1921 ret, NULL, "%p");
1922 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1923
1924 return TEST_SUCCESS;
1925 }
1926
1927 /**
1928 * Test execution of rte_security_capability_get with invalid
1929 * security operations structure (NULL)
1930 */
1931 static int
test_capability_get_inv_context_ops(void)1932 test_capability_get_inv_context_ops(void)
1933 {
1934 struct security_unittest_params *ut_params = &unittest_params;
1935 struct rte_security_capability_idx idx;
1936 ut_params->ctx.ops = NULL;
1937
1938 const struct rte_security_capability *ret;
1939 ret = rte_security_capability_get(&ut_params->ctx, &idx);
1940 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
1941 ret, NULL, "%p");
1942 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1943
1944 return TEST_SUCCESS;
1945 }
1946
1947 /**
1948 * Test execution of rte_security_capability_get with empty
1949 * security operations
1950 */
1951 static int
test_capability_get_inv_context_ops_fun(void)1952 test_capability_get_inv_context_ops_fun(void)
1953 {
1954 struct security_unittest_params *ut_params = &unittest_params;
1955 struct rte_security_capability_idx idx;
1956 ut_params->ctx.ops = &empty_ops;
1957
1958 const struct rte_security_capability *ret;
1959 ret = rte_security_capability_get(&ut_params->ctx, &idx);
1960 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
1961 ret, NULL, "%p");
1962 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1963
1964 return TEST_SUCCESS;
1965 }
1966
1967 /**
1968 * Test execution of rte_security_capability_get with NULL idx parameter
1969 */
1970 static int
test_capability_get_inv_idx(void)1971 test_capability_get_inv_idx(void)
1972 {
1973 struct security_unittest_params *ut_params = &unittest_params;
1974
1975 const struct rte_security_capability *ret;
1976 ret = rte_security_capability_get(&ut_params->ctx, NULL);
1977 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
1978 ret, NULL, "%p");
1979 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 0);
1980
1981 return TEST_SUCCESS;
1982 }
1983
1984 /**
1985 * Test execution of rte_security_capability_get when capabilities_get
1986 * security operation fails
1987 */
1988 static int
test_capability_get_ops_failure(void)1989 test_capability_get_ops_failure(void)
1990 {
1991 struct security_unittest_params *ut_params = &unittest_params;
1992 struct rte_security_capability_idx idx;
1993
1994 mock_capabilities_get_exp.device = NULL;
1995 mock_capabilities_get_exp.ret = NULL;
1996
1997 const struct rte_security_capability *ret;
1998 ret = rte_security_capability_get(&ut_params->ctx, &idx);
1999 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2000 ret, NULL, "%p");
2001 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2002
2003 return TEST_SUCCESS;
2004 }
2005
2006 /**
2007 * Test execution of rte_security_capability_get when capabilities table
2008 * is empty (contains only RTE_SECURITY_ACTION_TYPE_NONE ending entry)
2009 */
2010 static int
test_capability_get_empty_table(void)2011 test_capability_get_empty_table(void)
2012 {
2013 struct security_unittest_params *ut_params = &unittest_params;
2014 struct rte_security_capability_idx idx;
2015 struct rte_security_capability capabilities[] = {
2016 {
2017 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2018 },
2019 };
2020
2021 mock_capabilities_get_exp.device = NULL;
2022 mock_capabilities_get_exp.ret = capabilities;
2023
2024 const struct rte_security_capability *ret;
2025 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2026 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2027 ret, NULL, "%p");
2028 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2029
2030 return TEST_SUCCESS;
2031 }
2032
2033 /**
2034 * Test execution of rte_security_capability_get when capabilities table
2035 * does not contain entry with matching action
2036 */
2037 static int
test_capability_get_no_matching_action(void)2038 test_capability_get_no_matching_action(void)
2039 {
2040 struct security_unittest_params *ut_params = &unittest_params;
2041 struct rte_security_capability_idx idx = {
2042 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2043 };
2044 struct rte_security_capability capabilities[] = {
2045 {
2046 .action = RTE_SECURITY_ACTION_TYPE_INLINE_CRYPTO,
2047 },
2048 {
2049 .action = RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL,
2050 },
2051 {
2052 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2053 },
2054 };
2055
2056 mock_capabilities_get_exp.device = NULL;
2057 mock_capabilities_get_exp.ret = capabilities;
2058
2059 const struct rte_security_capability *ret;
2060 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2061 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2062 ret, NULL, "%p");
2063 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2064
2065 return TEST_SUCCESS;
2066 }
2067
2068 /**
2069 * Test execution of rte_security_capability_get when capabilities table
2070 * does not contain entry with matching protocol
2071 */
2072 static int
test_capability_get_no_matching_protocol(void)2073 test_capability_get_no_matching_protocol(void)
2074 {
2075 struct security_unittest_params *ut_params = &unittest_params;
2076 struct rte_security_capability_idx idx = {
2077 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2078 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2079 };
2080 struct rte_security_capability capabilities[] = {
2081 {
2082 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2083 .protocol = RTE_SECURITY_PROTOCOL_MACSEC,
2084 },
2085 {
2086 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2087 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
2088 },
2089 {
2090 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2091 },
2092 };
2093
2094 mock_capabilities_get_exp.device = NULL;
2095 mock_capabilities_get_exp.ret = capabilities;
2096
2097 const struct rte_security_capability *ret;
2098 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2099 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2100 ret, NULL, "%p");
2101 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2102
2103 return TEST_SUCCESS;
2104 }
2105
2106 /**
2107 * Test execution of rte_security_capability_get when macsec protocol
2108 * is searched and capabilities table contain proper entry.
2109 * However macsec records search is not supported in rte_security.
2110 */
2111 static int
test_capability_get_no_support_for_macsec(void)2112 test_capability_get_no_support_for_macsec(void)
2113 {
2114 struct security_unittest_params *ut_params = &unittest_params;
2115 struct rte_security_capability_idx idx = {
2116 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2117 .protocol = RTE_SECURITY_PROTOCOL_MACSEC,
2118 };
2119 struct rte_security_capability capabilities[] = {
2120 {
2121 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2122 .protocol = RTE_SECURITY_PROTOCOL_MACSEC,
2123 },
2124 {
2125 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2126 },
2127 };
2128
2129 mock_capabilities_get_exp.device = NULL;
2130 mock_capabilities_get_exp.ret = capabilities;
2131
2132 const struct rte_security_capability *ret;
2133 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2134 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2135 ret, NULL, "%p");
2136 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2137
2138 return TEST_SUCCESS;
2139 }
2140
2141 /**
2142 * Test execution of rte_security_capability_get when capabilities table
2143 * does not contain entry with matching ipsec proto field
2144 */
2145 static int
test_capability_get_ipsec_mismatch_proto(void)2146 test_capability_get_ipsec_mismatch_proto(void)
2147 {
2148 struct security_unittest_params *ut_params = &unittest_params;
2149 struct rte_security_capability_idx idx = {
2150 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2151 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2152 .ipsec = {
2153 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2154 },
2155 };
2156 struct rte_security_capability capabilities[] = {
2157 {
2158 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2159 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2160 .ipsec = {
2161 .proto = RTE_SECURITY_IPSEC_SA_PROTO_AH,
2162 },
2163 },
2164 {
2165 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2166 },
2167 };
2168
2169 mock_capabilities_get_exp.device = NULL;
2170 mock_capabilities_get_exp.ret = capabilities;
2171
2172 const struct rte_security_capability *ret;
2173 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2174 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2175 ret, NULL, "%p");
2176 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2177
2178 return TEST_SUCCESS;
2179 }
2180
2181 /**
2182 * Test execution of rte_security_capability_get when capabilities table
2183 * does not contain entry with matching ipsec mode field
2184 */
2185 static int
test_capability_get_ipsec_mismatch_mode(void)2186 test_capability_get_ipsec_mismatch_mode(void)
2187 {
2188 struct security_unittest_params *ut_params = &unittest_params;
2189 struct rte_security_capability_idx idx = {
2190 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2191 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2192 .ipsec = {
2193 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2194 .mode = RTE_SECURITY_IPSEC_SA_MODE_TRANSPORT,
2195 },
2196 };
2197 struct rte_security_capability capabilities[] = {
2198 {
2199 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2200 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2201 .ipsec = {
2202 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2203 .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
2204 },
2205 },
2206 {
2207 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2208 },
2209 };
2210
2211 mock_capabilities_get_exp.device = NULL;
2212 mock_capabilities_get_exp.ret = capabilities;
2213
2214 const struct rte_security_capability *ret;
2215 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2216 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2217 ret, NULL, "%p");
2218 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2219
2220 return TEST_SUCCESS;
2221 }
2222
2223 /**
2224 * Test execution of rte_security_capability_get when capabilities table
2225 * does not contain entry with matching ipsec direction field
2226 */
2227 static int
test_capability_get_ipsec_mismatch_dir(void)2228 test_capability_get_ipsec_mismatch_dir(void)
2229 {
2230 struct security_unittest_params *ut_params = &unittest_params;
2231 struct rte_security_capability_idx idx = {
2232 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2233 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2234 .ipsec = {
2235 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2236 .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
2237 .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS,
2238 },
2239 };
2240 struct rte_security_capability capabilities[] = {
2241 {
2242 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2243 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2244 .ipsec = {
2245 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2246 .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
2247 .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
2248 },
2249 },
2250 {
2251 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2252 },
2253 };
2254
2255 mock_capabilities_get_exp.device = NULL;
2256 mock_capabilities_get_exp.ret = capabilities;
2257
2258 const struct rte_security_capability *ret;
2259 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2260 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2261 ret, NULL, "%p");
2262 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2263
2264 return TEST_SUCCESS;
2265 }
2266
2267 /**
2268 * Test execution of rte_security_capability_get when capabilities table
2269 * contains matching ipsec entry
2270 */
2271 static int
test_capability_get_ipsec_match(void)2272 test_capability_get_ipsec_match(void)
2273 {
2274 struct security_unittest_params *ut_params = &unittest_params;
2275 struct rte_security_capability_idx idx = {
2276 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2277 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2278 .ipsec = {
2279 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2280 .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
2281 .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
2282 },
2283 };
2284 struct rte_security_capability capabilities[] = {
2285 {
2286 .action = RTE_SECURITY_ACTION_TYPE_INLINE_CRYPTO,
2287 },
2288 {
2289 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2290 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
2291 .ipsec = {
2292 .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
2293 .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
2294 .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
2295 },
2296 },
2297 {
2298 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2299 },
2300 };
2301
2302 mock_capabilities_get_exp.device = NULL;
2303 mock_capabilities_get_exp.ret = capabilities;
2304
2305 const struct rte_security_capability *ret;
2306 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2307 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2308 ret, &capabilities[1], "%p");
2309 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2310
2311 return TEST_SUCCESS;
2312 }
2313
2314 /**
2315 * Test execution of rte_security_capability_get when capabilities table
2316 * does not contain entry with matching pdcp domain field
2317 */
2318 static int
test_capability_get_pdcp_mismatch_domain(void)2319 test_capability_get_pdcp_mismatch_domain(void)
2320 {
2321 struct security_unittest_params *ut_params = &unittest_params;
2322 struct rte_security_capability_idx idx = {
2323 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2324 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
2325 .pdcp = {
2326 .domain = RTE_SECURITY_PDCP_MODE_CONTROL,
2327 },
2328 };
2329 struct rte_security_capability capabilities[] = {
2330 {
2331 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2332 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
2333 .pdcp = {
2334 .domain = RTE_SECURITY_PDCP_MODE_DATA,
2335 },
2336 },
2337 {
2338 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2339 },
2340 };
2341
2342 mock_capabilities_get_exp.device = NULL;
2343 mock_capabilities_get_exp.ret = capabilities;
2344
2345 const struct rte_security_capability *ret;
2346 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2347 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2348 ret, NULL, "%p");
2349 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2350
2351 return TEST_SUCCESS;
2352 }
2353
2354 /**
2355 * Test execution of rte_security_capability_get when capabilities table
2356 * contains matching pdcp entry
2357 */
2358 static int
test_capability_get_pdcp_match(void)2359 test_capability_get_pdcp_match(void)
2360 {
2361 struct security_unittest_params *ut_params = &unittest_params;
2362 struct rte_security_capability_idx idx = {
2363 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2364 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
2365 .pdcp = {
2366 .domain = RTE_SECURITY_PDCP_MODE_CONTROL,
2367 },
2368 };
2369 struct rte_security_capability capabilities[] = {
2370 {
2371 .action = RTE_SECURITY_ACTION_TYPE_INLINE_CRYPTO,
2372 },
2373 {
2374 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2375 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
2376 .pdcp = {
2377 .domain = RTE_SECURITY_PDCP_MODE_CONTROL,
2378 },
2379 },
2380 {
2381 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2382 },
2383 };
2384
2385 mock_capabilities_get_exp.device = NULL;
2386 mock_capabilities_get_exp.ret = capabilities;
2387
2388 const struct rte_security_capability *ret;
2389 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2390 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2391 ret, &capabilities[1], "%p");
2392 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2393
2394 return TEST_SUCCESS;
2395 }
2396
2397 /**
2398 * Test execution of rte_security_capability_get when capabilities table
2399 * does not contain entry with matching DOCSIS direction field
2400 */
2401 static int
test_capability_get_docsis_mismatch_direction(void)2402 test_capability_get_docsis_mismatch_direction(void)
2403 {
2404 struct security_unittest_params *ut_params = &unittest_params;
2405 struct rte_security_capability_idx idx = {
2406 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2407 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
2408 .docsis = {
2409 .direction = RTE_SECURITY_DOCSIS_DOWNLINK
2410 },
2411 };
2412 struct rte_security_capability capabilities[] = {
2413 {
2414 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2415 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
2416 .docsis = {
2417 .direction = RTE_SECURITY_DOCSIS_UPLINK
2418 },
2419 },
2420 {
2421 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2422 },
2423 };
2424
2425 mock_capabilities_get_exp.device = NULL;
2426 mock_capabilities_get_exp.ret = capabilities;
2427
2428 const struct rte_security_capability *ret;
2429 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2430 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2431 ret, NULL, "%p");
2432 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2433
2434 return TEST_SUCCESS;
2435 }
2436
2437 /**
2438 * Test execution of rte_security_capability_get when capabilities table
2439 * contains matching DOCSIS entry
2440 */
2441 static int
test_capability_get_docsis_match(void)2442 test_capability_get_docsis_match(void)
2443 {
2444 struct security_unittest_params *ut_params = &unittest_params;
2445 struct rte_security_capability_idx idx = {
2446 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2447 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
2448 .docsis = {
2449 .direction = RTE_SECURITY_DOCSIS_UPLINK
2450 },
2451 };
2452 struct rte_security_capability capabilities[] = {
2453 {
2454 .action = RTE_SECURITY_ACTION_TYPE_INLINE_CRYPTO,
2455 },
2456 {
2457 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
2458 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
2459 .docsis = {
2460 .direction = RTE_SECURITY_DOCSIS_UPLINK
2461 },
2462 },
2463 {
2464 .action = RTE_SECURITY_ACTION_TYPE_NONE,
2465 },
2466 };
2467
2468 mock_capabilities_get_exp.device = NULL;
2469 mock_capabilities_get_exp.ret = capabilities;
2470
2471 const struct rte_security_capability *ret;
2472 ret = rte_security_capability_get(&ut_params->ctx, &idx);
2473 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_capability_get,
2474 ret, &capabilities[1], "%p");
2475 TEST_ASSERT_MOCK_CALLS(mock_capabilities_get_exp, 1);
2476
2477 return TEST_SUCCESS;
2478 }
2479
2480 /**
2481 * Declaration of testcases
2482 */
2483 static struct unit_test_suite security_testsuite = {
2484 .suite_name = "generic security",
2485 .setup = testsuite_setup,
2486 .teardown = testsuite_teardown,
2487 .unit_test_cases = {
2488 TEST_CASE_ST(ut_setup, ut_teardown,
2489 test_session_create_inv_context),
2490 TEST_CASE_ST(ut_setup, ut_teardown,
2491 test_session_create_inv_context_ops),
2492 TEST_CASE_ST(ut_setup, ut_teardown,
2493 test_session_create_inv_context_ops_fun),
2494 TEST_CASE_ST(ut_setup, ut_teardown,
2495 test_session_create_inv_configuration),
2496 TEST_CASE_ST(ut_setup, ut_teardown,
2497 test_session_create_inv_mempool),
2498 TEST_CASE_ST(ut_setup, ut_teardown,
2499 test_session_create_inv_sess_priv_mempool),
2500 TEST_CASE_ST(ut_setup, ut_teardown,
2501 test_session_create_mempool_empty),
2502 TEST_CASE_ST(ut_setup, ut_teardown,
2503 test_session_create_ops_failure),
2504 TEST_CASE_ST(ut_setup, ut_teardown,
2505 test_session_create_success),
2506
2507 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2508 test_session_update_inv_context),
2509 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2510 test_session_update_inv_context_ops),
2511 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2512 test_session_update_inv_context_ops_fun),
2513 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2514 test_session_update_inv_configuration),
2515 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2516 test_session_update_inv_session),
2517 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2518 test_session_update_ops_failure),
2519 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2520 test_session_update_success),
2521
2522 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2523 test_session_get_size_inv_context),
2524 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2525 test_session_get_size_inv_context_ops),
2526 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2527 test_session_get_size_inv_context_ops_fun),
2528 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2529 test_session_get_size_ops_failure),
2530 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2531 test_session_get_size_success),
2532
2533 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2534 test_session_stats_get_inv_context),
2535 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2536 test_session_stats_get_inv_context_ops),
2537 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2538 test_session_stats_get_inv_context_ops_fun),
2539 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2540 test_session_stats_get_inv_stats),
2541 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2542 test_session_stats_get_ops_failure),
2543 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2544 test_session_stats_get_success),
2545
2546 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2547 test_session_destroy_inv_context),
2548 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2549 test_session_destroy_inv_context_ops),
2550 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2551 test_session_destroy_inv_context_ops_fun),
2552 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2553 test_session_destroy_inv_session),
2554 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2555 test_session_destroy_ops_failure),
2556 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2557 test_session_destroy_success),
2558
2559 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2560 test_set_pkt_metadata_inv_context),
2561 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2562 test_set_pkt_metadata_inv_context_ops),
2563 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2564 test_set_pkt_metadata_inv_context_ops_fun),
2565 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2566 test_set_pkt_metadata_inv_session),
2567 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2568 test_set_pkt_metadata_ops_failure),
2569 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2570 test_set_pkt_metadata_success),
2571
2572 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2573 test_get_userdata_inv_context),
2574 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2575 test_get_userdata_inv_context_ops),
2576 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2577 test_get_userdata_inv_context_ops_fun),
2578 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2579 test_get_userdata_ops_failure),
2580 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2581 test_get_userdata_success),
2582
2583 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2584 test_capabilities_get_inv_context),
2585 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2586 test_capabilities_get_inv_context_ops),
2587 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2588 test_capabilities_get_inv_context_ops_fun),
2589 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2590 test_capabilities_get_ops_failure),
2591 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2592 test_capabilities_get_success),
2593
2594 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2595 test_capability_get_inv_context),
2596 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2597 test_capability_get_inv_context_ops),
2598 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2599 test_capability_get_inv_context_ops_fun),
2600 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2601 test_capability_get_inv_idx),
2602 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2603 test_capability_get_ops_failure),
2604 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2605 test_capability_get_empty_table),
2606 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2607 test_capability_get_no_matching_action),
2608 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2609 test_capability_get_no_matching_protocol),
2610 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2611 test_capability_get_no_support_for_macsec),
2612 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2613 test_capability_get_ipsec_mismatch_proto),
2614 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2615 test_capability_get_ipsec_mismatch_mode),
2616 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2617 test_capability_get_ipsec_mismatch_dir),
2618 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2619 test_capability_get_ipsec_match),
2620 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2621 test_capability_get_pdcp_mismatch_domain),
2622 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2623 test_capability_get_pdcp_match),
2624 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2625 test_capability_get_docsis_mismatch_direction),
2626 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
2627 test_capability_get_docsis_match),
2628
2629 TEST_CASES_END() /**< NULL terminate unit test array */
2630 }
2631 };
2632
2633 static int
test_security(void)2634 test_security(void)
2635 {
2636 rte_log_set_global_level(RTE_LOG_DEBUG);
2637 rte_log_set_level(RTE_LOGTYPE_EAL, RTE_LOG_DEBUG);
2638
2639 return unit_test_suite_runner(&security_testsuite);
2640 }
2641
2642 REGISTER_TEST_COMMAND(security_autotest, test_security);
2643