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