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 detrmined 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 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 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 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 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 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 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 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 * 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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