1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
7 #include <rte_memory.h>
8 #include <rte_mempool.h>
9 #include <rte_security.h>
10 #include <rte_security_driver.h>
12 /* Before including rte_test.h file you can define
13 * RTE_TEST_TRACE_FAILURE(_file, _line, _func) macro to better trace/debug test
14 * failures. Mostly useful in development phase.
16 #ifndef RTE_TEST_TRACE_FAILURE
17 #define RTE_TEST_TRACE_FAILURE(_file, _line, _func) \
18 RTE_LOG(DEBUG, EAL, "in %s:%d %s\n", _file, _line, _func)
28 * Basic unit tests of the librte_security API.
30 * Structure of the file:
31 * - macros for making tests more readable;
32 * - mockup structures and functions for rte_security_ops;
33 * - test suite and test cases setup and teardown functions;
35 * - declaration of testcases.
42 * Set of macros for making tests easier to read.
46 * Verify condition inside mocked up function.
47 * Mockup function cannot return a test error, so the failure
48 * of assertion increases counter and print logs.
49 * The counter can be verified later to check if test case should fail.
51 * @param fail_counter fail counter
52 * @param cond condition expected to be true
53 * @param msg printf style formatting string for custom message
55 #define MOCK_TEST_ASSERT(fail_counter, cond, msg, ...) do { \
58 RTE_LOG(DEBUG, EAL, "Test assert %s line %d failed: " \
59 msg "\n", __func__, __LINE__, \
61 RTE_TEST_TRACE_FAILURE(__FILE__, __LINE__, __func__); \
66 * Verify equality condition inside mocked up function.
67 * Mockup function cannot return a test error, so the failure
68 * of assertion increases counter and print logs.
69 * The counter can be verified later to check if test case should fail.
71 * @param fail_counter fail counter
72 * @param a first value of comparison
73 * @param b second value of comparison
74 * @param msg printf style formatting string for custom message
76 #define MOCK_TEST_ASSERT_EQUAL(fail_counter, a, b, msg, ...) \
77 MOCK_TEST_ASSERT(fail_counter, (a) == (b), msg, ##__VA_ARGS__)
81 * Verify if parameter of the mocked up function matches expected value.
82 * The expected value is stored in data structure in the field matching
85 * @param data structure with expected values
86 * @param parameter name of the parameter (both field and parameter name)
87 * @param spec printf style spec for parameter
89 #define MOCK_TEST_ASSERT_PARAMETER(data, parameter, spec) \
90 MOCK_TEST_ASSERT_EQUAL(data.failed, data.parameter, parameter, \
91 "Expecting parameter %s to be " spec \
92 " but it's " spec, RTE_STR(parameter), \
93 data.parameter, parameter)
96 * Wrap for MOCK_TEST_ASSERT_PARAMETER macro for pointer type parameters.
98 * @param data structure with expected values
99 * @param parameter name of the parameter (both field and parameter name)
101 #define MOCK_TEST_ASSERT_POINTER_PARAMETER(data, parameter) \
102 MOCK_TEST_ASSERT_PARAMETER(data, parameter, "%p")
105 * Verify number of calls of the mocked up function
106 * and check if there were any fails during execution.
107 * The fails statistics inside mocked up functions are collected
108 * as "failed" field in mockup structures.
110 * @param mock_data structure with statistics (called, failed)
111 * @param exp_calls expected number of mockup function calls
113 #define TEST_ASSERT_MOCK_CALLS(mock_data, exp_calls) do { \
114 TEST_ASSERT_EQUAL(exp_calls, mock_data.called, \
115 "Expecting sub op to be called %d times, " \
116 "but it's called %d times", \
117 exp_calls, mock_data.called); \
118 TEST_ASSERT_EQUAL(0, mock_data.failed, \
119 "Expecting sub op asserts not to fail, " \
120 "but they're failed %d times", \
125 * Assert tested function result match expected value
127 * @param f_name name of tested function
128 * @param f_ret value returned by the function
129 * @param exp_ret expected returned value
130 * @param fmt printf style format for returned value
132 #define TEST_ASSERT_MOCK_FUNCTION_CALL_RET(f_name, f_ret, exp_ret, fmt) \
133 TEST_ASSERT_EQUAL(exp_ret, f_ret, "Expecting " RTE_STR(f_name) \
134 " to return " fmt ", but it returned " fmt \
135 "\n", exp_ret, f_ret)
138 * Assert tested function result is not NULL
140 * @param f_name name of tested function
141 * @param f_ret value returned by the function
143 #define TEST_ASSERT_MOCK_FUNCTION_CALL_NOT_NULL(f_name, f_ret) \
144 TEST_ASSERT_NOT_NULL(f_ret, "Expecting " RTE_STR(f_name) \
145 " to return not NULL\n")
148 * Verify that sess_cnt counter value matches expected
150 * @param expected_sessions_count expected counter value
152 #define TEST_ASSERT_SESSION_COUNT(expected_sessions_count) do { \
153 struct security_unittest_params *ut_params = &unittest_params; \
154 TEST_ASSERT_EQUAL(expected_sessions_count, \
155 ut_params->ctx.sess_cnt, \
156 "Expecting session counter to be %u," \
157 " but it's %u", expected_sessions_count, \
158 ut_params->ctx.sess_cnt); \
162 * Verify usage of mempool by checking if number of allocated objects matches
163 * expectations. The mempool is used to manage objects for sessions data.
164 * A single object is acquired from mempool during session_create
165 * and put back in session_destroy.
167 * @param expected_mempool_usage expected number of used mempool objects
169 #define TEST_ASSERT_MEMPOOL_USAGE(expected_mempool_usage) do { \
170 struct security_testsuite_params *ts_params = &testsuite_params;\
171 unsigned int mempool_usage; \
172 mempool_usage = rte_mempool_in_use_count( \
173 ts_params->session_mpool); \
174 TEST_ASSERT_EQUAL(expected_mempool_usage, mempool_usage, \
175 "Expecting %u mempool allocations, " \
176 "but there are %u allocated objects", \
177 expected_mempool_usage, mempool_usage); \
182 * Mockup structures and functions for rte_security_ops;
184 * Set of structures for controlling mockup functions calls.
185 * Every mockup function X has its corresponding X_data structure
186 * and an instance of that structure X_exp.
187 * Structure contains parameters that a mockup function is expected
188 * to be called with, a value to return (.ret) and 2 statistics:
189 * .called (number of times the mockup function was called)
190 * and .failed (number of assertion fails during mockup function call).
192 * Mockup functions verify that the parameters they are called with match
193 * expected values. The expected values should be stored in corresponding
194 * structures prior to mockup functions call. Every failure of such
195 * verification increases .failed counter. Every call of mockup function
196 * increases .called counter. Function returns value stored in .ret field
198 * In case of some parameters in some functions the expected value is unknown
199 * and cannot be detrmined prior to call. Such parameters are stored
200 * in structure and can be compared or analyzed later in test case code.
202 * Below structures and functions follow the rules just described.
203 * Additional remarks and exceptions are added in comments.
207 * session_create mockup
209 * Verified parameters: device, conf, mp.
210 * Saved, not verified parameters: sess.
212 static struct mock_session_create_data {
214 struct rte_security_session_conf *conf;
215 struct rte_security_session *sess;
216 struct rte_mempool *mp;
222 } mock_session_create_exp = {NULL, NULL, NULL, NULL, 0, 0, 0};
225 mock_session_create(void *device,
226 struct rte_security_session_conf *conf,
227 struct rte_security_session *sess,
228 struct rte_mempool *mp)
230 mock_session_create_exp.called++;
232 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_create_exp, device);
233 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_create_exp, conf);
234 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_create_exp, mp);
236 mock_session_create_exp.sess = sess;
238 return mock_session_create_exp.ret;
242 * session_update mockup
244 * Verified parameters: device, sess, conf.
246 static struct mock_session_update_data {
248 struct rte_security_session *sess;
249 struct rte_security_session_conf *conf;
255 } mock_session_update_exp = {NULL, NULL, NULL, 0, 0, 0};
258 mock_session_update(void *device,
259 struct rte_security_session *sess,
260 struct rte_security_session_conf *conf)
262 mock_session_update_exp.called++;
264 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_update_exp, device);
265 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_update_exp, sess);
266 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_update_exp, conf);
268 return mock_session_update_exp.ret;
272 * session_get_size mockup
274 * Verified parameters: device.
276 static struct mock_session_get_size_data {
283 } mock_session_get_size_exp = {NULL, 0U, 0, 0};
286 mock_session_get_size(void *device)
288 mock_session_get_size_exp.called++;
290 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_get_size_exp, device);
292 return mock_session_get_size_exp.ret;
296 * session_destroy mockup
298 * Verified parameters: device, sess.
300 static struct mock_session_destroy_data {
302 struct rte_security_session *sess;
308 } mock_session_destroy_exp = {NULL, NULL, 0, 0, 0};
311 mock_session_destroy(void *device, struct rte_security_session *sess)
313 mock_session_destroy_exp.called++;
315 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_destroy_exp, device);
316 MOCK_TEST_ASSERT_POINTER_PARAMETER(mock_session_destroy_exp, sess);
318 return mock_session_destroy_exp.ret;
324 * is an empty security operations set (all function pointers set to NULL)
326 struct rte_security_ops empty_ops = { NULL };
331 * is a security operations set using mockup functions
333 struct rte_security_ops mock_ops = {
334 .session_create = mock_session_create,
335 .session_update = mock_session_update,
336 .session_get_size = mock_session_get_size,
337 .session_destroy = mock_session_destroy,
342 * Test suite and test cases setup and teardown functions.
346 * struct security_testsuite_params defines parameters initialized once
347 * for whole tests suite.
348 * Currently the only stored parameter is session_mpool a mempool created
349 * once in testsuite_setup and released in testsuite_teardown.
350 * The instance of this structure is stored in testsuite_params variable.
352 static struct security_testsuite_params {
353 struct rte_mempool *session_mpool;
354 } testsuite_params = { NULL };
357 * struct security_unittest_params defines parameters initialized
358 * for every test case. The parameters are initialized in ut_setup
359 * or ut_setup_with_session (depending on the testcase)
360 * and released in ut_teardown.
361 * The instance of this structure is stored in unittest_params variable.
363 static struct security_unittest_params {
364 struct rte_security_ctx ctx;
365 struct rte_security_session_conf conf;
366 struct rte_security_session *sess;
367 } unittest_params = {
376 #define SECURITY_TEST_MEMPOOL_NAME "SecurityTestsMempoolName"
377 #define SECURITY_TEST_MEMPOOL_SIZE 15
378 #define SECURITY_TEST_SESSION_OBJECT_SIZE sizeof(struct rte_security_session)
381 * testsuite_setup initializes whole test suite parameters.
382 * It creates a new mempool used in all test cases
383 * and verifies if it properly created.
386 testsuite_setup(void)
388 struct security_testsuite_params *ts_params = &testsuite_params;
389 ts_params->session_mpool = rte_mempool_create(
390 SECURITY_TEST_MEMPOOL_NAME,
391 SECURITY_TEST_MEMPOOL_SIZE,
392 SECURITY_TEST_SESSION_OBJECT_SIZE,
393 0, 0, NULL, NULL, NULL, NULL,
395 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
396 "Cannot create mempool %s\n", rte_strerror(rte_errno));
401 * testsuite_teardown releases test suite wide parameters.
404 testsuite_teardown(void)
406 struct security_testsuite_params *ts_params = &testsuite_params;
407 if (ts_params->session_mpool) {
408 rte_mempool_free(ts_params->session_mpool);
409 ts_params->session_mpool = NULL;
414 * ut_setup initializes test case parameters to default values.
415 * It resets also any .called and .failed statistics of mockup functions
421 struct security_unittest_params *ut_params = &unittest_params;
422 ut_params->ctx.device = NULL;
423 ut_params->ctx.ops = &mock_ops;
424 ut_params->ctx.sess_cnt = 0;
425 ut_params->sess = NULL;
427 mock_session_create_exp.called = 0;
428 mock_session_update_exp.called = 0;
429 mock_session_get_size_exp.called = 0;
430 mock_session_destroy_exp.called = 0;
432 mock_session_create_exp.failed = 0;
433 mock_session_update_exp.failed = 0;
434 mock_session_get_size_exp.failed = 0;
435 mock_session_destroy_exp.failed = 0;
441 * destroy_session_with_check is a helper function releasing session
442 * created with rte_security_session_create and stored in test case parameters.
443 * It's used both to release sessions created in test cases' bodies
444 * which are assigned to ut_params->sess
445 * as well as sessions created in ut_setup_with_session.
448 destroy_session_with_check(void)
450 struct security_unittest_params *ut_params = &unittest_params;
451 if (ut_params->sess != NULL) {
452 /* Assure that mockup function for destroy operation is set. */
453 ut_params->ctx.ops = &mock_ops;
455 mock_session_destroy_exp.device = NULL;
456 mock_session_destroy_exp.sess = ut_params->sess;
457 mock_session_destroy_exp.ret = 0;
458 mock_session_destroy_exp.called = 0;
459 mock_session_destroy_exp.failed = 0;
461 int ret = rte_security_session_destroy(&ut_params->ctx,
463 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_destroy,
465 TEST_ASSERT_MOCK_CALLS(mock_session_destroy_exp, 1);
467 ut_params->sess = NULL;
473 * ut_teardown releases test case parameters.
478 destroy_session_with_check();
482 * ut_setup_with_session initializes test case parameters by
483 * - calling standard ut_setup,
484 * - creating a session that can be used in test case.
487 ut_setup_with_session(void)
489 struct security_unittest_params *ut_params = &unittest_params;
490 struct security_testsuite_params *ts_params = &testsuite_params;
491 struct rte_security_session *sess;
493 int ret = ut_setup();
494 if (ret != TEST_SUCCESS)
497 mock_session_create_exp.device = NULL;
498 mock_session_create_exp.conf = &ut_params->conf;
499 mock_session_create_exp.mp = ts_params->session_mpool;
500 mock_session_create_exp.ret = 0;
502 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
503 ts_params->session_mpool);
504 TEST_ASSERT_MOCK_FUNCTION_CALL_NOT_NULL(rte_security_session_create,
506 TEST_ASSERT_EQUAL(sess, mock_session_create_exp.sess,
507 "Expecting session_create to be called with %p sess"
508 " parameter, but it's called %p sess parameter",
509 sess, mock_session_create_exp.sess);
510 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 1);
513 * Store created session in test case parameters, so it can be released
514 * after test case in ut_teardown by destroy_session_with_check.
516 ut_params->sess = sess;
525 * Each test function is related to a single test case.
526 * They are arranged by tested rte_security API function
527 * and by rte_security execution paths sequence in code.
531 * rte_security_session_create tests
535 * Test execution of rte_security_session_create with NULL instance
538 test_session_create_inv_context(void)
540 struct security_testsuite_params *ts_params = &testsuite_params;
541 struct security_unittest_params *ut_params = &unittest_params;
542 struct rte_security_session *sess;
544 sess = rte_security_session_create(NULL, &ut_params->conf,
545 ts_params->session_mpool);
546 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
548 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
549 TEST_ASSERT_MEMPOOL_USAGE(0);
550 TEST_ASSERT_SESSION_COUNT(0);
556 * Test execution of rte_security_session_create with invalid
557 * security operations structure (NULL)
560 test_session_create_inv_context_ops(void)
562 struct security_testsuite_params *ts_params = &testsuite_params;
563 struct security_unittest_params *ut_params = &unittest_params;
564 struct rte_security_session *sess;
566 ut_params->ctx.ops = NULL;
568 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
569 ts_params->session_mpool);
570 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
572 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
573 TEST_ASSERT_MEMPOOL_USAGE(0);
574 TEST_ASSERT_SESSION_COUNT(0);
580 * Test execution of rte_security_session_create with empty
581 * security operations
584 test_session_create_inv_context_ops_fun(void)
586 struct security_testsuite_params *ts_params = &testsuite_params;
587 struct security_unittest_params *ut_params = &unittest_params;
588 struct rte_security_session *sess;
590 ut_params->ctx.ops = &empty_ops;
592 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
593 ts_params->session_mpool);
594 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
596 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
597 TEST_ASSERT_MEMPOOL_USAGE(0);
598 TEST_ASSERT_SESSION_COUNT(0);
604 * Test execution of rte_security_session_create with NULL conf parameter
607 test_session_create_inv_configuration(void)
609 struct security_testsuite_params *ts_params = &testsuite_params;
610 struct security_unittest_params *ut_params = &unittest_params;
611 struct rte_security_session *sess;
613 sess = rte_security_session_create(&ut_params->ctx, NULL,
614 ts_params->session_mpool);
615 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
617 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
618 TEST_ASSERT_MEMPOOL_USAGE(0);
619 TEST_ASSERT_SESSION_COUNT(0);
625 * Test execution of rte_security_session_create with NULL mp parameter
628 test_session_create_inv_mempool(void)
630 struct security_unittest_params *ut_params = &unittest_params;
631 struct rte_security_session *sess;
633 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
635 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
637 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
638 TEST_ASSERT_MEMPOOL_USAGE(0);
639 TEST_ASSERT_SESSION_COUNT(0);
645 * Test execution of rte_security_session_create in case when mempool
646 * is fully used and no object can be got from it
649 test_session_create_mempool_empty(void)
651 struct security_testsuite_params *ts_params = &testsuite_params;
652 struct security_unittest_params *ut_params = &unittest_params;
653 struct rte_security_session *tmp[SECURITY_TEST_MEMPOOL_SIZE];
654 struct rte_security_session *sess;
656 /* Get all available objects from mempool. */
658 for (i = 0; i < SECURITY_TEST_MEMPOOL_SIZE; ++i) {
659 ret = rte_mempool_get(ts_params->session_mpool,
661 TEST_ASSERT_EQUAL(0, ret,
662 "Expect getting %d object from mempool"
665 TEST_ASSERT_MEMPOOL_USAGE(SECURITY_TEST_MEMPOOL_SIZE);
667 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
668 ts_params->session_mpool);
669 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
671 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 0);
672 TEST_ASSERT_MEMPOOL_USAGE(SECURITY_TEST_MEMPOOL_SIZE);
673 TEST_ASSERT_SESSION_COUNT(0);
675 /* Put objects back to the pool. */
676 for (i = 0; i < SECURITY_TEST_MEMPOOL_SIZE; ++i)
677 rte_mempool_put(ts_params->session_mpool, (void *)(tmp[i]));
678 TEST_ASSERT_MEMPOOL_USAGE(0);
684 * Test execution of rte_security_session_create when session_create
685 * security operation fails
688 test_session_create_ops_failure(void)
690 struct security_testsuite_params *ts_params = &testsuite_params;
691 struct security_unittest_params *ut_params = &unittest_params;
692 struct rte_security_session *sess;
694 mock_session_create_exp.device = NULL;
695 mock_session_create_exp.conf = &ut_params->conf;
696 mock_session_create_exp.mp = ts_params->session_mpool;
697 mock_session_create_exp.ret = -1; /* Return failure status. */
699 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
700 ts_params->session_mpool);
701 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_create,
703 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 1);
704 TEST_ASSERT_MEMPOOL_USAGE(0);
705 TEST_ASSERT_SESSION_COUNT(0);
711 * Test execution of rte_security_session_create in successful execution path
714 test_session_create_success(void)
716 struct security_testsuite_params *ts_params = &testsuite_params;
717 struct security_unittest_params *ut_params = &unittest_params;
718 struct rte_security_session *sess;
720 mock_session_create_exp.device = NULL;
721 mock_session_create_exp.conf = &ut_params->conf;
722 mock_session_create_exp.mp = ts_params->session_mpool;
723 mock_session_create_exp.ret = 0; /* Return success status. */
725 sess = rte_security_session_create(&ut_params->ctx, &ut_params->conf,
726 ts_params->session_mpool);
727 TEST_ASSERT_MOCK_FUNCTION_CALL_NOT_NULL(rte_security_session_create,
729 TEST_ASSERT_EQUAL(sess, mock_session_create_exp.sess,
730 "Expecting session_create to be called with %p sess"
731 " parameter, but it's called %p sess parameter",
732 sess, mock_session_create_exp.sess);
733 TEST_ASSERT_MOCK_CALLS(mock_session_create_exp, 1);
734 TEST_ASSERT_MEMPOOL_USAGE(1);
735 TEST_ASSERT_SESSION_COUNT(1);
738 * Store created session in test case parameters, so it can be released
739 * after test case in ut_teardown by destroy_session_with_check.
741 ut_params->sess = sess;
748 * rte_security_session_update tests
752 * Test execution of rte_security_session_update with NULL instance
755 test_session_update_inv_context(void)
757 struct security_unittest_params *ut_params = &unittest_params;
759 int ret = rte_security_session_update(NULL, ut_params->sess,
761 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
763 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
769 * Test execution of rte_security_session_update with invalid
770 * security operations structure (NULL)
773 test_session_update_inv_context_ops(void)
775 struct security_unittest_params *ut_params = &unittest_params;
776 ut_params->ctx.ops = NULL;
778 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
780 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
782 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
788 * Test execution of rte_security_session_update with empty
789 * security operations
792 test_session_update_inv_context_ops_fun(void)
794 struct security_unittest_params *ut_params = &unittest_params;
795 ut_params->ctx.ops = &empty_ops;
797 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
799 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
800 ret, -ENOTSUP, "%d");
801 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
807 * Test execution of rte_security_session_update with NULL conf parameter
810 test_session_update_inv_configuration(void)
812 struct security_unittest_params *ut_params = &unittest_params;
814 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
816 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
818 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
824 * Test execution of rte_security_session_update with NULL sess parameter
827 test_session_update_inv_session(void)
829 struct security_unittest_params *ut_params = &unittest_params;
831 int ret = rte_security_session_update(&ut_params->ctx, NULL,
833 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
835 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 0);
841 * Test execution of rte_security_session_update when session_update
842 * security operation fails
845 test_session_update_ops_failure(void)
847 struct security_unittest_params *ut_params = &unittest_params;
849 mock_session_update_exp.device = NULL;
850 mock_session_update_exp.sess = ut_params->sess;
851 mock_session_update_exp.conf = &ut_params->conf;
852 mock_session_update_exp.ret = -1; /* Return failure status. */
854 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
856 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
858 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 1);
864 * Test execution of rte_security_session_update in successful execution path
867 test_session_update_success(void)
869 struct security_unittest_params *ut_params = &unittest_params;
871 mock_session_update_exp.device = NULL;
872 mock_session_update_exp.sess = ut_params->sess;
873 mock_session_update_exp.conf = &ut_params->conf;
874 mock_session_update_exp.ret = 0; /* Return success status. */
876 int ret = rte_security_session_update(&ut_params->ctx, ut_params->sess,
878 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_update,
880 TEST_ASSERT_MOCK_CALLS(mock_session_update_exp, 1);
887 * rte_security_session_get_size tests
891 * Test execution of rte_security_session_get_size with NULL instance
894 test_session_get_size_inv_context(void)
896 unsigned int ret = rte_security_session_get_size(NULL);
897 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
899 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 0);
905 * Test execution of rte_security_session_get_size with invalid
906 * security operations structure (NULL)
909 test_session_get_size_inv_context_ops(void)
911 struct security_unittest_params *ut_params = &unittest_params;
912 ut_params->ctx.ops = NULL;
914 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
915 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
917 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 0);
923 * Test execution of rte_security_session_get_size with empty
924 * security operations
927 test_session_get_size_inv_context_ops_fun(void)
929 struct security_unittest_params *ut_params = &unittest_params;
930 ut_params->ctx.ops = &empty_ops;
932 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
933 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
935 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 0);
941 * Test execution of rte_security_session_get_size when session_get_size
942 * security operation fails
945 test_session_get_size_ops_failure(void)
947 struct security_unittest_params *ut_params = &unittest_params;
949 mock_session_get_size_exp.device = NULL;
950 mock_session_get_size_exp.ret = 0;
952 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
953 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
955 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 1);
961 * Test execution of rte_security_session_get_size in successful execution path
964 test_session_get_size_success(void)
966 struct security_unittest_params *ut_params = &unittest_params;
968 mock_session_get_size_exp.device = NULL;
969 mock_session_get_size_exp.ret = 1024;
971 unsigned int ret = rte_security_session_get_size(&ut_params->ctx);
972 TEST_ASSERT_MOCK_FUNCTION_CALL_RET(rte_security_session_get_size,
974 TEST_ASSERT_MOCK_CALLS(mock_session_get_size_exp, 1);
981 * Declaration of testcases
983 static struct unit_test_suite security_testsuite = {
984 .suite_name = "generic security",
985 .setup = testsuite_setup,
986 .teardown = testsuite_teardown,
988 TEST_CASE_ST(ut_setup, ut_teardown,
989 test_session_create_inv_context),
990 TEST_CASE_ST(ut_setup, ut_teardown,
991 test_session_create_inv_context_ops),
992 TEST_CASE_ST(ut_setup, ut_teardown,
993 test_session_create_inv_context_ops_fun),
994 TEST_CASE_ST(ut_setup, ut_teardown,
995 test_session_create_inv_configuration),
996 TEST_CASE_ST(ut_setup, ut_teardown,
997 test_session_create_inv_mempool),
998 TEST_CASE_ST(ut_setup, ut_teardown,
999 test_session_create_mempool_empty),
1000 TEST_CASE_ST(ut_setup, ut_teardown,
1001 test_session_create_ops_failure),
1002 TEST_CASE_ST(ut_setup, ut_teardown,
1003 test_session_create_success),
1005 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1006 test_session_update_inv_context),
1007 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1008 test_session_update_inv_context_ops),
1009 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1010 test_session_update_inv_context_ops_fun),
1011 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1012 test_session_update_inv_configuration),
1013 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1014 test_session_update_inv_session),
1015 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1016 test_session_update_ops_failure),
1017 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1018 test_session_update_success),
1020 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1021 test_session_get_size_inv_context),
1022 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1023 test_session_get_size_inv_context_ops),
1024 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1025 test_session_get_size_inv_context_ops_fun),
1026 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1027 test_session_get_size_ops_failure),
1028 TEST_CASE_ST(ut_setup_with_session, ut_teardown,
1029 test_session_get_size_success),
1031 TEST_CASES_END() /**< NULL terminate unit test array */
1038 rte_log_set_global_level(RTE_LOG_DEBUG);
1039 rte_log_set_level(RTE_LOGTYPE_EAL, RTE_LOG_DEBUG);
1041 return unit_test_suite_runner(&security_testsuite);
1044 REGISTER_TEST_COMMAND(security_autotest, test_security);