[1/1] test/crypto: refactor unit tests into one combined array
diff mbox series

Message ID 20191211161015.9845-2-adamx.dybkowski@intel.com
State Superseded
Headers show
Series
  • Refactor crypto unit tests.
Related show

Checks

Context Check Description
ci/Intel-compilation fail apply issues
ci/checkpatch warning coding style issues

Commit Message

Adam Dybkowski Dec. 11, 2019, 4:10 p.m. UTC
This patch refactors most of unit tests to be contained in one
combined array, and run depending on the PMD capabilities instead of
providing multiple array with tests for individual PMDs.
Only a subset of unit tests was merged into one array - it combines
all tests originally meant to be run on these PMDs:
null, aesni_mb, aesni_gcm, openssl, qat, sw_snow3g, sw_kasumi, sw_zuc.

Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
---
 app/test/test_cryptodev.c                  | 16113 +++++++++----------
 app/test/test_cryptodev_blockcipher.c      |     2 +-
 app/test/test_cryptodev_des_test_vectors.h |     6 +-
 3 files changed, 7430 insertions(+), 8691 deletions(-)

Patch
diff mbox series

diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 9c2b99200..9fe0d9995 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -669,6 +669,13 @@  test_device_configure_invalid_queue_pair_ids(void)
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 
+	/* This test is for QAT and NITROX PMDs only */
+	if (gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)) &&
+	    gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_NITROX_PMD)))
+		return -ENOTSUP;
+
 	/* Stop the device in case it's started so it can be configured */
 	rte_cryptodev_stop(ts_params->valid_devs[0]);
 
@@ -740,6 +747,11 @@  test_queue_pair_descriptor_setup(void)
 
 	uint16_t qp_id;
 
+	/* This test is for QAT PMD only */
+	if (gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))
+		return -ENOTSUP;
+
 	/* Stop the device in case it's started so it can be configured */
 	rte_cryptodev_stop(ts_params->valid_devs[0]);
 
@@ -1348,6 +1360,19 @@  test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
 	/* Generate test mbuf data and space for digest */
 	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 			catch_22_quote,	QUOTE_512_BYTES, 0);
@@ -1591,7 +1616,7 @@  test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 }
 
 static int
-test_AES_cipheronly_mb_all(void)
+test_blockcipher(enum blockcipher_test_type test_type)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	int status;
@@ -1600,9 +1625,11 @@  test_AES_cipheronly_mb_all(void)
 		ts_params->op_mpool,
 		ts_params->session_mpool, ts_params->session_priv_mpool,
 		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+		gbl_driver_id,
+		test_type);
+
+	if (status == -ENOTSUP)
+		return status;
 
 	TEST_ASSERT_EQUAL(status, 0, "Test failed");
 
@@ -1610,1572 +1637,1650 @@  test_AES_cipheronly_mb_all(void)
 }
 
 static int
-test_AES_docsis_mb_all(void)
+test_AES_cipheronly_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_AES_DOCSIS_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
 }
 
 static int
-test_AES_docsis_qat_all(void)
+test_AES_docsis_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_AES_DOCSIS_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
 }
 
 static int
-test_DES_docsis_qat_all(void)
+test_DES_docsis_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_DES_DOCSIS_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
 }
 
 static int
-test_authonly_mb_all(void)
+test_DES_cipheronly_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
 }
 
 static int
-test_authonly_qat_all(void)
+test_authonly_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
 }
 
 static int
-test_AES_chain_null_all(void)
+test_AES_chain_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
 }
 
 static int
-test_AES_cipheronly_null_all(void)
+test_3DES_chain_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
 }
 
 static int
-test_authonly_null_all(void)
+test_3DES_cipheronly_all(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_NULL_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
 }
 
+/* ***** SNOW 3G Tests ***** */
 static int
-test_AES_chain_mb_all(void)
+create_wireless_algo_hash_session(uint8_t dev_id,
+	const uint8_t *key, const uint8_t key_len,
+	const uint8_t iv_len, const uint8_t auth_len,
+	enum rte_crypto_auth_operation op,
+	enum rte_crypto_auth_algorithm algo)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	uint8_t hash_key[key_len];
 	int status;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+	memcpy(hash_key, key, key_len);
 
-static int
-test_AES_cipheronly_scheduler_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	debug_hexdump(stdout, "key:", key, key_len);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	/* Setup Authentication Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	ut_params->auth_xform.auth.op = op;
+	ut_params->auth_xform.auth.algo = algo;
+	ut_params->auth_xform.auth.key.length = key_len;
+	ut_params->auth_xform.auth.key.data = hash_key;
+	ut_params->auth_xform.auth.digest_length = auth_len;
+	ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+	ut_params->auth_xform.auth.iv.length = iv_len;
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	return TEST_SUCCESS;
+	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->auth_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_EQUAL(status, 0, "session init failed");
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	return 0;
 }
 
 static int
-test_AES_chain_scheduler_all(void)
+create_wireless_algo_cipher_session(uint8_t dev_id,
+			enum rte_crypto_cipher_operation op,
+			enum rte_crypto_cipher_algorithm algo,
+			const uint8_t *key, const uint8_t key_len,
+			uint8_t iv_len)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	uint8_t cipher_key[key_len];
 	int status;
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	memcpy(cipher_key, key, key_len);
 
-	return TEST_SUCCESS;
-}
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = NULL;
 
-static int
-test_authonly_scheduler_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	ut_params->cipher_xform.cipher.algo = algo;
+	ut_params->cipher_xform.cipher.op = op;
+	ut_params->cipher_xform.cipher.key.data = cipher_key;
+	ut_params->cipher_xform.cipher.key.length = key_len;
+	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+	ut_params->cipher_xform.cipher.iv.length = iv_len;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	debug_hexdump(stdout, "key:", key, key_len);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Create Crypto session */
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	return TEST_SUCCESS;
+	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_EQUAL(status, 0, "session init failed");
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	return 0;
 }
 
-#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
-
 static int
-test_AES_chain_openssl_all(void)
+create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
+			unsigned int cipher_len,
+			unsigned int cipher_offset)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	return TEST_SUCCESS;
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+				RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+				"Failed to allocate pktmbuf offload");
 
-static int
-test_AES_cipheronly_openssl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	return TEST_SUCCESS;
+	/* iv */
+	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+			IV_OFFSET), iv, iv_len);
+	sym_op->cipher.data.length = cipher_len;
+	sym_op->cipher.data.offset = cipher_offset;
+	return 0;
 }
 
 static int
-test_AES_chain_ccp_all(void)
+create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
+			unsigned int cipher_len,
+			unsigned int cipher_offset)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+				RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+				"Failed to allocate pktmbuf offload");
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	return TEST_SUCCESS;
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
+	sym_op->m_dst = ut_params->obuf;
+
+	/* iv */
+	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+			IV_OFFSET), iv, iv_len);
+	sym_op->cipher.data.length = cipher_len;
+	sym_op->cipher.data.offset = cipher_offset;
+	return 0;
 }
 
 static int
-test_AES_cipheronly_ccp_all(void)
+create_wireless_algo_cipher_auth_session(uint8_t dev_id,
+		enum rte_crypto_cipher_operation cipher_op,
+		enum rte_crypto_auth_operation auth_op,
+		enum rte_crypto_auth_algorithm auth_algo,
+		enum rte_crypto_cipher_algorithm cipher_algo,
+		const uint8_t *key, uint8_t key_len,
+		uint8_t auth_iv_len, uint8_t auth_len,
+		uint8_t cipher_iv_len)
+
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	uint8_t cipher_auth_key[key_len];
 	int status;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	memcpy(cipher_auth_key, key, key_len);
 
-	return TEST_SUCCESS;
-}
+	/* Setup Authentication Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-static int
-test_AES_chain_qat_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	ut_params->auth_xform.auth.op = auth_op;
+	ut_params->auth_xform.auth.algo = auth_algo;
+	ut_params->auth_xform.auth.key.length = key_len;
+	/* Hash key = cipher key */
+	ut_params->auth_xform.auth.key.data = cipher_auth_key;
+	ut_params->auth_xform.auth.digest_length = auth_len;
+	/* Auth IV will be after cipher IV */
+	ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
+	ut_params->auth_xform.auth.iv.length = auth_iv_len;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = &ut_params->auth_xform;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	ut_params->cipher_xform.cipher.algo = cipher_algo;
+	ut_params->cipher_xform.cipher.op = cipher_op;
+	ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
+	ut_params->cipher_xform.cipher.key.length = key_len;
+	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+	ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
 
-	return TEST_SUCCESS;
+	debug_hexdump(stdout, "key:", key, key_len);
+
+	/* Create Crypto session*/
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+
+	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
+	if (status == -ENOTSUP)
+		return status;
+
+	TEST_ASSERT_EQUAL(status, 0, "session init failed");
+	return 0;
 }
 
 static int
-test_AES_cipheronly_qat_all(void)
+create_wireless_cipher_auth_session(uint8_t dev_id,
+		enum rte_crypto_cipher_operation cipher_op,
+		enum rte_crypto_auth_operation auth_op,
+		enum rte_crypto_auth_algorithm auth_algo,
+		enum rte_crypto_cipher_algorithm cipher_algo,
+		const struct wireless_test_data *tdata)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	const uint8_t key_len = tdata->key.len;
+	uint8_t cipher_auth_key[key_len];
 	int status;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+	const uint8_t *key = tdata->key.data;
+	const uint8_t auth_len = tdata->digest.len;
+	uint8_t cipher_iv_len = tdata->cipher_iv.len;
+	uint8_t auth_iv_len = tdata->auth_iv.len;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	memcpy(cipher_auth_key, key, key_len);
 
-	return TEST_SUCCESS;
-}
+	/* Setup Authentication Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-static int
-test_AES_cipheronly_virtio_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	ut_params->auth_xform.auth.op = auth_op;
+	ut_params->auth_xform.auth.algo = auth_algo;
+	ut_params->auth_xform.auth.key.length = key_len;
+	/* Hash key = cipher key */
+	ut_params->auth_xform.auth.key.data = cipher_auth_key;
+	ut_params->auth_xform.auth.digest_length = auth_len;
+	/* Auth IV will be after cipher IV */
+	ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
+	ut_params->auth_xform.auth.iv.length = auth_iv_len;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = &ut_params->auth_xform;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	ut_params->cipher_xform.cipher.algo = cipher_algo;
+	ut_params->cipher_xform.cipher.op = cipher_op;
+	ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
+	ut_params->cipher_xform.cipher.key.length = key_len;
+	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+	ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
 
-	return TEST_SUCCESS;
-}
 
-static int
-test_AES_chain_caam_jr_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	debug_hexdump(stdout, "key:", key, key_len);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	/* Create Crypto session*/
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
 
-	return TEST_SUCCESS;
+	TEST_ASSERT_EQUAL(status, 0, "session init failed");
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	return 0;
 }
 
 static int
-test_AES_cipheronly_caam_jr_all(void)
+create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
+		const struct wireless_test_data *tdata)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return create_wireless_cipher_auth_session(dev_id,
+		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+		RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
+		RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
 }
 
 static int
-test_authonly_caam_jr_all(void)
+create_wireless_algo_auth_cipher_session(uint8_t dev_id,
+		enum rte_crypto_cipher_operation cipher_op,
+		enum rte_crypto_auth_operation auth_op,
+		enum rte_crypto_auth_algorithm auth_algo,
+		enum rte_crypto_cipher_algorithm cipher_algo,
+		const uint8_t *key, const uint8_t key_len,
+		uint8_t auth_iv_len, uint8_t auth_len,
+		uint8_t cipher_iv_len)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	uint8_t auth_cipher_key[key_len];
 	int status;
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	memcpy(auth_cipher_key, key, key_len);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Setup Authentication Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.auth.op = auth_op;
+	ut_params->auth_xform.next = &ut_params->cipher_xform;
+	ut_params->auth_xform.auth.algo = auth_algo;
+	ut_params->auth_xform.auth.key.length = key_len;
+	ut_params->auth_xform.auth.key.data = auth_cipher_key;
+	ut_params->auth_xform.auth.digest_length = auth_len;
+	/* Auth IV will be after cipher IV */
+	ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
+	ut_params->auth_xform.auth.iv.length = auth_iv_len;
 
-	return TEST_SUCCESS;
-}
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = NULL;
+	ut_params->cipher_xform.cipher.algo = cipher_algo;
+	ut_params->cipher_xform.cipher.op = cipher_op;
+	ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
+	ut_params->cipher_xform.cipher.key.length = key_len;
+	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+	ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
 
+	debug_hexdump(stdout, "key:", key, key_len);
 
-static int
-test_AES_chain_dpaa_sec_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Create Crypto session*/
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->auth_xform,
+			ts_params->session_priv_mpool);
+	if (status == -ENOTSUP)
+		return status;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	TEST_ASSERT_EQUAL(status, 0, "session init failed");
 
-	return TEST_SUCCESS;
+	return 0;
 }
 
 static int
-test_AES_cipheronly_dpaa_sec_all(void)
+create_wireless_algo_hash_operation(const uint8_t *auth_tag,
+		unsigned int auth_tag_len,
+		const uint8_t *iv, unsigned int iv_len,
+		unsigned int data_pad_len,
+		enum rte_crypto_auth_operation op,
+		unsigned int auth_len, unsigned int auth_offset)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+		"Failed to allocate pktmbuf offload");
 
-	return TEST_SUCCESS;
-}
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-static int
-test_authonly_dpaa_sec_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	return TEST_SUCCESS;
-}
+	/* iv */
+	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+			IV_OFFSET), iv, iv_len);
+	/* digest */
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+					ut_params->ibuf, auth_tag_len);
 
-static int
-test_AES_chain_dpaa2_sec_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+				"no room to append auth tag");
+	ut_params->digest = sym_op->auth.digest.data;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			ut_params->ibuf, data_pad_len);
+	if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
+		memset(sym_op->auth.digest.data, 0, auth_tag_len);
+	else
+		rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	debug_hexdump(stdout, "digest:",
+		sym_op->auth.digest.data,
+		auth_tag_len);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	sym_op->auth.data.length = auth_len;
+	sym_op->auth.data.offset = auth_offset;
 
-	return TEST_SUCCESS;
+	return 0;
 }
 
 static int
-test_AES_cipheronly_dpaa2_sec_all(void)
+create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
+	enum rte_crypto_auth_operation op)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	const uint8_t *auth_tag = tdata->digest.data;
+	const unsigned int auth_tag_len = tdata->digest.len;
+	unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	const uint8_t *cipher_iv = tdata->cipher_iv.data;
+	const uint8_t cipher_iv_len = tdata->cipher_iv.len;
+	const uint8_t *auth_iv = tdata->auth_iv.data;
+	const uint8_t auth_iv_len = tdata->auth_iv.len;
+	const unsigned int cipher_len = tdata->validCipherLenInBits.len;
+	const unsigned int auth_len = tdata->validAuthLenInBits.len;
 
-	return TEST_SUCCESS;
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate pktmbuf offload");
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-static int
-test_authonly_dpaa2_sec_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* digest */
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+			ut_params->ibuf, auth_tag_len);
 
-	return TEST_SUCCESS;
-}
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+			"no room to append auth tag");
+	ut_params->digest = sym_op->auth.digest.data;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			ut_params->ibuf, data_pad_len);
+	if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
+		memset(sym_op->auth.digest.data, 0, auth_tag_len);
+	else
+		rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
 
-static int
-test_authonly_openssl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	debug_hexdump(stdout, "digest:",
+		sym_op->auth.digest.data,
+		auth_tag_len);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	/* Copy cipher and auth IVs at the end of the crypto operation */
+	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+						IV_OFFSET);
+	rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
+	iv_ptr += cipher_iv_len;
+	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	sym_op->cipher.data.length = cipher_len;
+	sym_op->cipher.data.offset = 0;
+	sym_op->auth.data.length = auth_len;
+	sym_op->auth.data.offset = 0;
 
-	return TEST_SUCCESS;
+	return 0;
 }
 
 static int
-test_authonly_ccp_all(void)
+create_zuc_cipher_hash_generate_operation(
+		const struct wireless_test_data *tdata)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return create_wireless_cipher_hash_operation(tdata,
+		RTE_CRYPTO_AUTH_OP_GENERATE);
 }
 
 static int
-test_AES_chain_armv8_all(void)
+create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
+		const unsigned auth_tag_len,
+		const uint8_t *auth_iv, uint8_t auth_iv_len,
+		unsigned data_pad_len,
+		enum rte_crypto_auth_operation op,
+		const uint8_t *cipher_iv, uint8_t cipher_iv_len,
+		const unsigned cipher_len, const unsigned cipher_offset,
+		const unsigned auth_len, const unsigned auth_offset)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	enum rte_crypto_cipher_algorithm cipher_algo =
+			ut_params->cipher_xform.cipher.algo;
+	enum rte_crypto_auth_algorithm auth_algo =
+			ut_params->auth_xform.auth.algo;
 
-	return TEST_SUCCESS;
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate pktmbuf offload");
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-static int
-test_AES_chain_mrvl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* digest */
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+			ut_params->ibuf, auth_tag_len);
 
-	return TEST_SUCCESS;
-}
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+			"no room to append auth tag");
+	ut_params->digest = sym_op->auth.digest.data;
 
-static int
-test_AES_cipheronly_mrvl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
+		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+				ut_params->ibuf, data_pad_len);
+	} else {
+		struct rte_mbuf *m = ut_params->ibuf;
+		unsigned int offset = data_pad_len;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+		while (offset > m->data_len && m->next != NULL) {
+			offset -= m->data_len;
+			m = m->next;
+		}
+		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			m, offset);
+	}
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
+		memset(sym_op->auth.digest.data, 0, auth_tag_len);
+	else
+		rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
 
-	return TEST_SUCCESS;
-}
+	debug_hexdump(stdout, "digest:",
+		sym_op->auth.digest.data,
+		auth_tag_len);
 
-static int
-test_authonly_mrvl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Copy cipher and auth IVs at the end of the crypto operation */
+	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+						IV_OFFSET);
+	rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
+	iv_ptr += cipher_iv_len;
+	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
+		cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
+		cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
+		sym_op->cipher.data.length = cipher_len;
+		sym_op->cipher.data.offset = cipher_offset;
+	} else {
+		sym_op->cipher.data.length = cipher_len >> 3;
+		sym_op->cipher.data.offset = cipher_offset >> 3;
+	}
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
+		auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
+		auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
+		sym_op->auth.data.length = auth_len;
+		sym_op->auth.data.offset = auth_offset;
+	} else {
+		sym_op->auth.data.length = auth_len >> 3;
+		sym_op->auth.data.offset = auth_offset >> 3;
+	}
 
-	return TEST_SUCCESS;
+	return 0;
 }
 
 static int
-test_3DES_chain_mrvl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
+create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
+		const uint8_t *cipher_iv, uint8_t cipher_iv_len,
+		const uint8_t *auth_iv, uint8_t auth_iv_len,
+		unsigned int data_pad_len,
+		unsigned int cipher_len, unsigned int cipher_offset,
+		unsigned int auth_len, unsigned int auth_offset,
+		uint8_t op_mode, uint8_t do_sgl)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	enum rte_crypto_cipher_algorithm cipher_algo =
+			ut_params->cipher_xform.cipher.algo;
+	enum rte_crypto_auth_algorithm auth_algo =
+			ut_params->auth_xform.auth.algo;
 
-	return TEST_SUCCESS;
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate pktmbuf offload");
 
-static int
-test_3DES_cipheronly_mrvl_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* set crypto operation mbufs */
+	sym_op->m_src = ut_params->ibuf;
+	if (op_mode == OUT_OF_PLACE)
+		sym_op->m_dst = ut_params->obuf;
 
-	return TEST_SUCCESS;
-}
+	/* digest */
+	if (!do_sgl) {
+		sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
+			(op_mode == IN_PLACE ?
+				ut_params->ibuf : ut_params->obuf),
+			uint8_t *, data_pad_len);
+		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			(op_mode == IN_PLACE ?
+				ut_params->ibuf : ut_params->obuf),
+			data_pad_len);
+		memset(sym_op->auth.digest.data, 0, auth_tag_len);
+	} else {
+		uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
+		struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
+				sym_op->m_src : sym_op->m_dst);
+		while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
+			remaining_off -= rte_pktmbuf_data_len(sgl_buf);
+			sgl_buf = sgl_buf->next;
+		}
+		sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
+				uint8_t *, remaining_off);
+		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
+				remaining_off);
+		memset(sym_op->auth.digest.data, 0, remaining_off);
+		while (sgl_buf->next != NULL) {
+			memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
+				0, rte_pktmbuf_data_len(sgl_buf));
+			sgl_buf = sgl_buf->next;
+		}
+	}
 
-static int
-test_AES_chain_octeontx_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Copy cipher and auth IVs at the end of the crypto operation */
+	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
+			ut_params->op, uint8_t *, IV_OFFSET);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
+	iv_ptr += cipher_iv_len;
+	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
+		cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
+		cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
+		sym_op->cipher.data.length = cipher_len;
+		sym_op->cipher.data.offset = cipher_offset;
+	} else {
+		sym_op->cipher.data.length = cipher_len >> 3;
+		sym_op->cipher.data.offset = cipher_offset >> 3;
+	}
 
-	return TEST_SUCCESS;
+	if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
+		auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
+		auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
+		sym_op->auth.data.length = auth_len;
+		sym_op->auth.data.offset = auth_offset;
+	} else {
+		sym_op->auth.data.length = auth_len >> 3;
+		sym_op->auth.data.offset = auth_offset >> 3;
+	}
+
+	return 0;
 }
 
 static int
-test_AES_cipheronly_octeontx_all(void)
+test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	int retval;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
+	uint8_t *plaintext;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* QAT PMD supports byte-aligned data only */
+	if ((tdata->validAuthLenInBits.len % 8 != 0) &&
+			(gbl_driver_id == rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))))
+		return -ENOTSUP;
 
-	return TEST_SUCCESS;
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_3DES_chain_octeontx_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
+			tdata->key.data, tdata->key.len,
+			tdata->auth_iv.len, tdata->digest.len,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			RTE_CRYPTO_AUTH_SNOW3G_UIA2);
+	if (retval < 0)
+		return retval;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
+	/* alloc mbuf and set payload */
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	return TEST_SUCCESS;
-}
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-static int
-test_AES_chain_nitrox_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
+			tdata->auth_iv.data, tdata->auth_iv.len,
+			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+			tdata->validAuthLenInBits.len,
+			0);
+	if (retval < 0)
+		return retval;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_NITROX_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+				ut_params->op);
+	ut_params->obuf = ut_params->op->sym->m_src;
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+			+ plaintext_pad_len;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+	ut_params->digest,
+	tdata->digest.data,
+	DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
+	"SNOW 3G Generated auth tag not as expected");
 
-	return TEST_SUCCESS;
+	return 0;
 }
 
 static int
-test_3DES_cipheronly_octeontx_all(void)
+test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
+	int retval;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
+	uint8_t *plaintext;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* QAT PMD supports byte-aligned data only */
+	if ((tdata->validAuthLenInBits.len % 8 != 0) &&
+			(gbl_driver_id == rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))))
+		return -ENOTSUP;
 
-	return TEST_SUCCESS;
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_authonly_octeontx_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
+				tdata->key.data, tdata->key.len,
+				tdata->auth_iv.len, tdata->digest.len,
+				RTE_CRYPTO_AUTH_OP_VERIFY,
+				RTE_CRYPTO_AUTH_SNOW3G_UIA2);
+	if (retval < 0)
+		return retval;
+	/* alloc mbuf and set payload */
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	return TEST_SUCCESS;
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_hash_operation(tdata->digest.data,
+			tdata->digest.len,
+			tdata->auth_iv.data, tdata->auth_iv.len,
+			plaintext_pad_len,
+			RTE_CRYPTO_AUTH_OP_VERIFY,
+			tdata->validAuthLenInBits.len,
+			0);
+	if (retval < 0)
+		return retval;
+
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+				ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+	ut_params->obuf = ut_params->op->sym->m_src;
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+				+ plaintext_pad_len;
+
+	/* Validate obuf */
+	if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
+		return 0;
+	else
+		return -1;
+
+	return 0;
 }
 
 static int
-test_AES_chain_octeontx2_all(void)
+test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
-		BLKCIPHER_AES_CHAIN_TYPE);
+	int retval;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
+	uint8_t *plaintext;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	return TEST_SUCCESS;
-}
+	/* Create KASUMI session */
+	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
+			tdata->key.data, tdata->key.len,
+			0, tdata->digest.len,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			RTE_CRYPTO_AUTH_KASUMI_F9);
+	if (retval < 0)
+		return retval;
 
-static int
-test_AES_cipheronly_octeontx2_all(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	/* alloc mbuf and set payload */
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
-		BLKCIPHER_AES_CIPHERONLY_TYPE);
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	return TEST_SUCCESS;
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
+			NULL, 0,
+			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+			tdata->plaintext.len,
+			0);
+	if (retval < 0)
+		return retval;
+
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+				ut_params->op);
+	ut_params->obuf = ut_params->op->sym->m_src;
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+			+ plaintext_pad_len;
+
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+	ut_params->digest,
+	tdata->digest.data,
+	DIGEST_BYTE_LENGTH_KASUMI_F9,
+	"KASUMI Generated auth tag not as expected");
+
+	return 0;
 }
 
 static int
-test_3DES_chain_octeontx2_all(void)
+test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
+	int retval;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
+	uint8_t *plaintext;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	return TEST_SUCCESS;
+	/* Create KASUMI session */
+	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
+				tdata->key.data, tdata->key.len,
+				0, tdata->digest.len,
+				RTE_CRYPTO_AUTH_OP_VERIFY,
+				RTE_CRYPTO_AUTH_KASUMI_F9);
+	if (retval < 0)
+		return retval;
+	/* alloc mbuf and set payload */
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	rte_pktmbuf_tailroom(ut_params->ibuf));
+
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_hash_operation(tdata->digest.data,
+			tdata->digest.len,
+			NULL, 0,
+			plaintext_pad_len,
+			RTE_CRYPTO_AUTH_OP_VERIFY,
+			tdata->plaintext.len,
+			0);
+	if (retval < 0)
+		return retval;
+
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+				ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+	ut_params->obuf = ut_params->op->sym->m_src;
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+				+ plaintext_pad_len;
+
+	/* Validate obuf */
+	if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
+		return 0;
+	else
+		return -1;
+
+	return 0;
 }
 
 static int
-test_3DES_cipheronly_octeontx2_all(void)
+test_snow3g_hash_generate_test_case_1(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	return test_snow3g_authentication(&snow3g_hash_test_case_1);
+}
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
+static int
+test_snow3g_hash_generate_test_case_2(void)
+{
+	return test_snow3g_authentication(&snow3g_hash_test_case_2);
+}
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+static int
+test_snow3g_hash_generate_test_case_3(void)
+{
+	return test_snow3g_authentication(&snow3g_hash_test_case_3);
+}
 
-	return TEST_SUCCESS;
+static int
+test_snow3g_hash_generate_test_case_4(void)
+{
+	return test_snow3g_authentication(&snow3g_hash_test_case_4);
 }
 
 static int
-test_authonly_octeontx2_all(void)
+test_snow3g_hash_generate_test_case_5(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	return test_snow3g_authentication(&snow3g_hash_test_case_5);
+}
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool, ts_params->session_mpool,
-		ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)),
-		BLKCIPHER_AUTHONLY_TYPE);
+static int
+test_snow3g_hash_generate_test_case_6(void)
+{
+	return test_snow3g_authentication(&snow3g_hash_test_case_6);
+}
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+static int
+test_snow3g_hash_verify_test_case_1(void)
+{
+	return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
 
-	return TEST_SUCCESS;
 }
 
-/* ***** SNOW 3G Tests ***** */
 static int
-create_wireless_algo_hash_session(uint8_t dev_id,
-	const uint8_t *key, const uint8_t key_len,
-	const uint8_t iv_len, const uint8_t auth_len,
-	enum rte_crypto_auth_operation op,
-	enum rte_crypto_auth_algorithm algo)
+test_snow3g_hash_verify_test_case_2(void)
 {
-	uint8_t hash_key[key_len];
-	int status;
-
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
+}
 
-	memcpy(hash_key, key, key_len);
+static int
+test_snow3g_hash_verify_test_case_3(void)
+{
+	return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
+}
 
-	debug_hexdump(stdout, "key:", key, key_len);
+static int
+test_snow3g_hash_verify_test_case_4(void)
+{
+	return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
+}
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
+static int
+test_snow3g_hash_verify_test_case_5(void)
+{
+	return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
+}
 
-	ut_params->auth_xform.auth.op = op;
-	ut_params->auth_xform.auth.algo = algo;
-	ut_params->auth_xform.auth.key.length = key_len;
-	ut_params->auth_xform.auth.key.data = hash_key;
-	ut_params->auth_xform.auth.digest_length = auth_len;
-	ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
-	ut_params->auth_xform.auth.iv.length = iv_len;
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+static int
+test_snow3g_hash_verify_test_case_6(void)
+{
+	return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
+}
 
-	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->auth_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_EQUAL(status, 0, "session init failed");
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-	return 0;
+static int
+test_kasumi_hash_generate_test_case_1(void)
+{
+	return test_kasumi_authentication(&kasumi_hash_test_case_1);
 }
 
 static int
-create_wireless_algo_cipher_session(uint8_t dev_id,
-			enum rte_crypto_cipher_operation op,
-			enum rte_crypto_cipher_algorithm algo,
-			const uint8_t *key, const uint8_t key_len,
-			uint8_t iv_len)
+test_kasumi_hash_generate_test_case_2(void)
 {
-	uint8_t cipher_key[key_len];
-	int status;
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_kasumi_authentication(&kasumi_hash_test_case_2);
+}
 
-	memcpy(cipher_key, key, key_len);
+static int
+test_kasumi_hash_generate_test_case_3(void)
+{
+	return test_kasumi_authentication(&kasumi_hash_test_case_3);
+}
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = NULL;
+static int
+test_kasumi_hash_generate_test_case_4(void)
+{
+	return test_kasumi_authentication(&kasumi_hash_test_case_4);
+}
 
-	ut_params->cipher_xform.cipher.algo = algo;
-	ut_params->cipher_xform.cipher.op = op;
-	ut_params->cipher_xform.cipher.key.data = cipher_key;
-	ut_params->cipher_xform.cipher.key.length = key_len;
-	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-	ut_params->cipher_xform.cipher.iv.length = iv_len;
-
-	debug_hexdump(stdout, "key:", key, key_len);
-
-	/* Create Crypto session */
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
-
-	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_EQUAL(status, 0, "session init failed");
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-	return 0;
+static int
+test_kasumi_hash_generate_test_case_5(void)
+{
+	return test_kasumi_authentication(&kasumi_hash_test_case_5);
 }
 
 static int
-create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
-			unsigned int cipher_len,
-			unsigned int cipher_offset)
+test_kasumi_hash_generate_test_case_6(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-				RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-				"Failed to allocate pktmbuf offload");
-
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
-
-	/* iv */
-	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
-			iv, iv_len);
-	sym_op->cipher.data.length = cipher_len;
-	sym_op->cipher.data.offset = cipher_offset;
-	return 0;
+	return test_kasumi_authentication(&kasumi_hash_test_case_6);
 }
 
 static int
-create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
-			unsigned int cipher_len,
-			unsigned int cipher_offset)
+test_kasumi_hash_verify_test_case_1(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-				RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-				"Failed to allocate pktmbuf offload");
-
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
+}
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
-	sym_op->m_dst = ut_params->obuf;
+static int
+test_kasumi_hash_verify_test_case_2(void)
+{
+	return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
+}
 
-	/* iv */
-	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
-			iv, iv_len);
-	sym_op->cipher.data.length = cipher_len;
-	sym_op->cipher.data.offset = cipher_offset;
-	return 0;
+static int
+test_kasumi_hash_verify_test_case_3(void)
+{
+	return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
 }
 
 static int
-create_wireless_algo_cipher_auth_session(uint8_t dev_id,
-		enum rte_crypto_cipher_operation cipher_op,
-		enum rte_crypto_auth_operation auth_op,
-		enum rte_crypto_auth_algorithm auth_algo,
-		enum rte_crypto_cipher_algorithm cipher_algo,
-		const uint8_t *key, uint8_t key_len,
-		uint8_t auth_iv_len, uint8_t auth_len,
-		uint8_t cipher_iv_len)
+test_kasumi_hash_verify_test_case_4(void)
+{
+	return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
+}
 
+static int
+test_kasumi_hash_verify_test_case_5(void)
 {
-	uint8_t cipher_auth_key[key_len];
-	int status;
+	return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
+}
 
+static int
+test_kasumi_encryption(const struct kasumi_test_data *tdata)
+{
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	memcpy(cipher_auth_key, key, key_len);
+	int retval;
+	uint8_t *plaintext, *ciphertext;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	ut_params->auth_xform.auth.op = auth_op;
-	ut_params->auth_xform.auth.algo = auth_algo;
-	ut_params->auth_xform.auth.key.length = key_len;
-	/* Hash key = cipher key */
-	ut_params->auth_xform.auth.key.data = cipher_auth_key;
-	ut_params->auth_xform.auth.digest_length = auth_len;
-	/* Auth IV will be after cipher IV */
-	ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
-	ut_params->auth_xform.auth.iv.length = auth_iv_len;
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = &ut_params->auth_xform;
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	ut_params->cipher_xform.cipher.algo = cipher_algo;
-	ut_params->cipher_xform.cipher.op = cipher_op;
-	ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
-	ut_params->cipher_xform.cipher.key.length = key_len;
-	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-	ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
+	/* Clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	debug_hexdump(stdout, "key:", key, key_len);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
-	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
-	if (status == -ENOTSUP)
-		return status;
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len,
+						8),
+				tdata->validCipherOffsetInBits.len);
+	if (retval < 0)
+		return retval;
 
-	TEST_ASSERT_EQUAL(status, 0, "session init failed");
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	else
+		ciphertext = plaintext +
+				(tdata->validCipherOffsetInBits.len >> 3);
+
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		reference_ciphertext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Ciphertext data not as expected");
 	return 0;
 }
 
 static int
-create_wireless_cipher_auth_session(uint8_t dev_id,
-		enum rte_crypto_cipher_operation cipher_op,
-		enum rte_crypto_auth_operation auth_op,
-		enum rte_crypto_auth_algorithm auth_algo,
-		enum rte_crypto_cipher_algorithm cipher_algo,
-		const struct wireless_test_data *tdata)
+test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 {
-	const uint8_t key_len = tdata->key.len;
-	uint8_t cipher_auth_key[key_len];
-	int status;
-
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
-	const uint8_t *key = tdata->key.data;
-	const uint8_t auth_len = tdata->digest.len;
-	uint8_t cipher_iv_len = tdata->cipher_iv.len;
-	uint8_t auth_iv_len = tdata->auth_iv.len;
 
-	memcpy(cipher_auth_key, key, key_len);
+	int retval;
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
 
-	ut_params->auth_xform.auth.op = auth_op;
-	ut_params->auth_xform.auth.algo = auth_algo;
-	ut_params->auth_xform.auth.key.length = key_len;
-	/* Hash key = cipher key */
-	ut_params->auth_xform.auth.key.data = cipher_auth_key;
-	ut_params->auth_xform.auth.digest_length = auth_len;
-	/* Auth IV will be after cipher IV */
-	ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
-	ut_params->auth_xform.auth.iv.length = auth_iv_len;
+	uint8_t buffer[10000];
+	const uint8_t *ciphertext;
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = &ut_params->auth_xform;
+	struct rte_cryptodev_info dev_info;
 
-	ut_params->cipher_xform.cipher.algo = cipher_algo;
-	ut_params->cipher_xform.cipher.op = cipher_op;
-	ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
-	ut_params->cipher_xform.cipher.key.length = key_len;
-	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-	ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	debug_hexdump(stdout, "key:", key, key_len);
+	uint64_t feat_flags = dev_info.feature_flags;
 
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
+		printf("Device doesn't support in-place scatter-gather. "
+				"Test Skipped.\n");
+		return -ENOTSUP;
+	}
 
-	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-	TEST_ASSERT_EQUAL(status, 0, "session init failed");
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-	return 0;
-}
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
 
-static int
-create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
-		const struct wireless_test_data *tdata)
-{
-	return create_wireless_cipher_auth_session(dev_id,
-		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-		RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
-		RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
-}
 
-static int
-create_wireless_algo_auth_cipher_session(uint8_t dev_id,
-		enum rte_crypto_cipher_operation cipher_op,
-		enum rte_crypto_auth_operation auth_op,
-		enum rte_crypto_auth_algorithm auth_algo,
-		enum rte_crypto_cipher_algorithm cipher_algo,
-		const uint8_t *key, const uint8_t key_len,
-		uint8_t auth_iv_len, uint8_t auth_len,
-		uint8_t cipher_iv_len)
-{
-	uint8_t auth_cipher_key[key_len];
-	int status;
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
 
-	memcpy(auth_cipher_key, key, key_len);
+	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 10, 0);
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.auth.op = auth_op;
-	ut_params->auth_xform.next = &ut_params->cipher_xform;
-	ut_params->auth_xform.auth.algo = auth_algo;
-	ut_params->auth_xform.auth.key.length = key_len;
-	ut_params->auth_xform.auth.key.data = auth_cipher_key;
-	ut_params->auth_xform.auth.digest_length = auth_len;
-	/* Auth IV will be after cipher IV */
-	ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
-	ut_params->auth_xform.auth.iv.length = auth_iv_len;
+	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = NULL;
-	ut_params->cipher_xform.cipher.algo = cipher_algo;
-	ut_params->cipher_xform.cipher.op = cipher_op;
-	ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
-	ut_params->cipher_xform.cipher.key.length = key_len;
-	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-	ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len,
+						8),
+				tdata->validCipherOffsetInBits.len);
+	if (retval < 0)
+		return retval;
 
-	debug_hexdump(stdout, "key:", key, key_len);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	ut_params->obuf = ut_params->op->sym->m_dst;
 
-	status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->auth_xform,
-			ts_params->session_priv_mpool);
-	if (status == -ENOTSUP)
-		return status;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
+				plaintext_len, buffer);
+	else
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+				tdata->validCipherOffsetInBits.len >> 3,
+				plaintext_len, buffer);
 
-	TEST_ASSERT_EQUAL(status, 0, "session init failed");
+	/* Validate obuf */
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		reference_ciphertext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Ciphertext data not as expected");
 	return 0;
 }
 
 static int
-create_wireless_algo_hash_operation(const uint8_t *auth_tag,
-		unsigned int auth_tag_len,
-		const uint8_t *iv, unsigned int iv_len,
-		unsigned int data_pad_len,
-		enum rte_crypto_auth_operation op,
-		unsigned int auth_len, unsigned int auth_offset)
+test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-		"Failed to allocate pktmbuf offload");
+	int retval;
+	uint8_t *plaintext, *ciphertext;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
 
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* iv */
-	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
-			iv, iv_len);
-	/* digest */
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-					ut_params->ibuf, auth_tag_len);
+	/* Clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-				"no room to append auth tag");
-	ut_params->digest = sym_op->auth.digest.data;
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, data_pad_len);
-	if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
-		memset(sym_op->auth.digest.data, 0, auth_tag_len);
-	else
-		rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	debug_hexdump(stdout, "digest:",
-		sym_op->auth.digest.data,
-		auth_tag_len);
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
-	sym_op->auth.data.length = auth_len;
-	sym_op->auth.data.offset = auth_offset;
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_operation_oop(
+				tdata->cipher_iv.data,
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len,
+						8),
+				tdata->validCipherOffsetInBits.len);
+	if (retval < 0)
+		return retval;
+
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	else
+		ciphertext = plaintext +
+				(tdata->validCipherOffsetInBits.len >> 3);
 
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		reference_ciphertext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Ciphertext data not as expected");
 	return 0;
 }
 
 static int
-create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
-	enum rte_crypto_auth_operation op)
+test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	const uint8_t *auth_tag = tdata->digest.data;
-	const unsigned int auth_tag_len = tdata->digest.len;
-	unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	int retval;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
 
-	const uint8_t *cipher_iv = tdata->cipher_iv.data;
-	const uint8_t cipher_iv_len = tdata->cipher_iv.len;
-	const uint8_t *auth_iv = tdata->auth_iv.data;
-	const uint8_t auth_iv_len = tdata->auth_iv.len;
-	const unsigned int cipher_len = tdata->validCipherLenInBits.len;
-	const unsigned int auth_len = tdata->validAuthLenInBits.len;
+	const uint8_t *ciphertext;
+	uint8_t buffer[2048];
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate pktmbuf offload");
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	struct rte_cryptodev_info dev_info;
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	/* digest */
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, auth_tag_len);
+	uint64_t feat_flags = dev_info.feature_flags;
+	if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
+		printf("Device doesn't support out-of-place scatter-gather "
+				"in both input and output mbufs. "
+				"Test Skipped.\n");
+		return -ENOTSUP;
+	}
 
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append auth tag");
-	ut_params->digest = sym_op->auth.digest.data;
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, data_pad_len);
-	if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
-		memset(sym_op->auth.digest.data, 0, auth_tag_len);
-	else
-		rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-	debug_hexdump(stdout, "digest:",
-		sym_op->auth.digest.data,
-		auth_tag_len);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
 
-	/* Copy cipher and auth IVs at the end of the crypto operation */
-	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
-						IV_OFFSET);
-	rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
-	iv_ptr += cipher_iv_len;
-	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
+	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 10, 0);
+	ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 3, 0);
 
-	sym_op->cipher.data.length = cipher_len;
-	sym_op->cipher.data.offset = 0;
-	sym_op->auth.data.length = auth_len;
-	sym_op->auth.data.offset = 0;
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_operation_oop(
+				tdata->cipher_iv.data,
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len,
+						8),
+				tdata->validCipherOffsetInBits.len);
+	if (retval < 0)
+		return retval;
+
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
+				plaintext_pad_len, buffer);
+	else
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+				tdata->validCipherOffsetInBits.len >> 3,
+				plaintext_pad_len, buffer);
 
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		reference_ciphertext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Ciphertext data not as expected");
 	return 0;
 }
 
-static int
-create_zuc_cipher_hash_generate_operation(
-		const struct wireless_test_data *tdata)
-{
-	return create_wireless_cipher_hash_operation(tdata,
-		RTE_CRYPTO_AUTH_OP_GENERATE);
-}
 
 static int
-create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
-		const unsigned auth_tag_len,
-		const uint8_t *auth_iv, uint8_t auth_iv_len,
-		unsigned data_pad_len,
-		enum rte_crypto_auth_operation op,
-		const uint8_t *cipher_iv, uint8_t cipher_iv_len,
-		const unsigned cipher_len, const unsigned cipher_offset,
-		const unsigned auth_len, const unsigned auth_offset)
+test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	enum rte_crypto_cipher_algorithm cipher_algo =
-			ut_params->cipher_xform.cipher.algo;
-	enum rte_crypto_auth_algorithm auth_algo =
-			ut_params->auth_xform.auth.algo;
-
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate pktmbuf offload");
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	int retval;
+	uint8_t *ciphertext, *plaintext;
+	unsigned ciphertext_pad_len;
+	unsigned ciphertext_len;
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* digest */
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, auth_tag_len);
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_DECRYPT,
+					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append auth tag");
-	ut_params->digest = sym_op->auth.digest.data;
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
-		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-				ut_params->ibuf, data_pad_len);
-	} else {
-		struct rte_mbuf *m = ut_params->ibuf;
-		unsigned int offset = data_pad_len;
+	/* Clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-		while (offset > m->data_len && m->next != NULL) {
-			offset -= m->data_len;
-			m = m->next;
-		}
-		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			m, offset);
-	}
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
+	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				ciphertext_pad_len);
+	rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
+	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-	if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
-		memset(sym_op->auth.digest.data, 0, auth_tag_len);
-	else
-		rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
+	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
-	debug_hexdump(stdout, "digest:",
-		sym_op->auth.digest.data,
-		auth_tag_len);
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_operation_oop(
+				tdata->cipher_iv.data,
+				tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len,
+						8),
+				tdata->validCipherOffsetInBits.len);
+	if (retval < 0)
+		return retval;
 
-	/* Copy cipher and auth IVs at the end of the crypto operation */
-	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
-						IV_OFFSET);
-	rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
-	iv_ptr += cipher_iv_len;
-	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
-		cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
-		cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
-		sym_op->cipher.data.length = cipher_len;
-		sym_op->cipher.data.offset = cipher_offset;
-	} else {
-		sym_op->cipher.data.length = cipher_len >> 3;
-		sym_op->cipher.data.offset = cipher_offset >> 3;
-	}
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	else
+		plaintext = ciphertext +
+				(tdata->validCipherOffsetInBits.len >> 3);
 
-	if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
-		auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
-		auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
-		sym_op->auth.data.length = auth_len;
-		sym_op->auth.data.offset = auth_offset;
-	} else {
-		sym_op->auth.data.length = auth_len >> 3;
-		sym_op->auth.data.offset = auth_offset >> 3;
-	}
+	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
+	const uint8_t *reference_plaintext = tdata->plaintext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		plaintext,
+		reference_plaintext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Plaintext data not as expected");
 	return 0;
 }
 
 static int
-create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
-		const uint8_t *cipher_iv, uint8_t cipher_iv_len,
-		const uint8_t *auth_iv, uint8_t auth_iv_len,
-		unsigned int data_pad_len,
-		unsigned int cipher_len, unsigned int cipher_offset,
-		unsigned int auth_len, unsigned int auth_offset,
-		uint8_t op_mode, uint8_t do_sgl)
+test_kasumi_decryption(const struct kasumi_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	enum rte_crypto_cipher_algorithm cipher_algo =
-			ut_params->cipher_xform.cipher.algo;
-	enum rte_crypto_auth_algorithm auth_algo =
-			ut_params->auth_xform.auth.algo;
+	int retval;
+	uint8_t *ciphertext, *plaintext;
+	unsigned ciphertext_pad_len;
+	unsigned ciphertext_len;
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate pktmbuf offload");
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_DECRYPT,
+					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* set crypto operation mbufs */
-	sym_op->m_src = ut_params->ibuf;
-	if (op_mode == OUT_OF_PLACE)
-		sym_op->m_dst = ut_params->obuf;
+	/* Clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	/* digest */
-	if (!do_sgl) {
-		sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
-			(op_mode == IN_PLACE ?
-				ut_params->ibuf : ut_params->obuf),
-			uint8_t *, data_pad_len);
-		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			(op_mode == IN_PLACE ?
-				ut_params->ibuf : ut_params->obuf),
-			data_pad_len);
-		memset(sym_op->auth.digest.data, 0, auth_tag_len);
-	} else {
-		uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
-		struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
-				sym_op->m_src : sym_op->m_dst);
-		while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
-			remaining_off -= rte_pktmbuf_data_len(sgl_buf);
-			sgl_buf = sgl_buf->next;
-		}
-		sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
-				uint8_t *, remaining_off);
-		sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
-				remaining_off);
-		memset(sym_op->auth.digest.data, 0, remaining_off);
-		while (sgl_buf->next != NULL) {
-			memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
-				0, rte_pktmbuf_data_len(sgl_buf));
-			sgl_buf = sgl_buf->next;
-		}
-	}
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
+	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				ciphertext_pad_len);
+	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-	/* Copy cipher and auth IVs at the end of the crypto operation */
-	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
-			ut_params->op, uint8_t *, IV_OFFSET);
+	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
-	rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
-	iv_ptr += cipher_iv_len;
-	rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->ciphertext.len,
+					tdata->validCipherOffsetInBits.len);
+	if (retval < 0)
+		return retval;
 
-	if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
-		cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
-		cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
-		sym_op->cipher.data.length = cipher_len;
-		sym_op->cipher.data.offset = cipher_offset;
-	} else {
-		sym_op->cipher.data.length = cipher_len >> 3;
-		sym_op->cipher.data.offset = cipher_offset >> 3;
-	}
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
-		auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
-		auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
-		sym_op->auth.data.length = auth_len;
-		sym_op->auth.data.offset = auth_offset;
-	} else {
-		sym_op->auth.data.length = auth_len >> 3;
-		sym_op->auth.data.offset = auth_offset >> 3;
-	}
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	else
+		plaintext = ciphertext +
+				(tdata->validCipherOffsetInBits.len >> 3);
 
+	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
+
+	const uint8_t *reference_plaintext = tdata->plaintext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		plaintext,
+		reference_plaintext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Plaintext data not as expected");
 	return 0;
 }
 
 static int
-test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
+test_snow3g_encryption(const struct snow3g_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
+	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
-	uint8_t *plaintext;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
 	/* Create SNOW 3G session */
-	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
-			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			RTE_CRYPTO_AUTH_SNOW3G_UIA2);
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
-	/* alloc mbuf and set payload */
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
+	/* Clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	rte_pktmbuf_tailroom(ut_params->ibuf));
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
 	/* Append data which is padded to a multiple of */
@@ -3185,56 +3290,77 @@  test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
 				plaintext_pad_len);
 	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+
 	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
-			tdata->auth_iv.data, tdata->auth_iv.len,
-			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-			tdata->validAuthLenInBits.len,
-			0);
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->validCipherLenInBits.len,
+					0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-				ut_params->op);
-	ut_params->obuf = ut_params->op->sym->m_src;
+						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-			+ plaintext_pad_len;
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-	ut_params->digest,
-	tdata->digest.data,
-	DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
-	"SNOW 3G Generated auth tag not as expected");
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	else
+		ciphertext = plaintext;
+
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		tdata->ciphertext.data,
+		tdata->validDataLenInBits.len,
+		"SNOW 3G Ciphertext data not as expected");
 	return 0;
 }
 
+
 static int
-test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
+test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *plaintext, *ciphertext;
 
 	int retval;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
-	uint8_t *plaintext;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
 	/* Create SNOW 3G session */
-	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
-				tdata->key.data, tdata->key.len,
-				tdata->auth_iv.len, tdata->digest.len,
-				RTE_CRYPTO_AUTH_OP_VERIFY,
-				RTE_CRYPTO_AUTH_SNOW3G_UIA2);
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
-	/* alloc mbuf and set payload */
+
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
+	TEST_ASSERT_NOT_NULL(ut_params->obuf,
+			"Failed to allocate output buffer in mempool");
 
+	/* Clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	rte_pktmbuf_tailroom(ut_params->ibuf));
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
 	/* Append data which is padded to a multiple of */
@@ -3242,1176 +3368,1486 @@  test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
 	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 				plaintext_pad_len);
+	rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
 	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+
 	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_hash_operation(tdata->digest.data,
-			tdata->digest.len,
-			tdata->auth_iv.data, tdata->auth_iv.len,
-			plaintext_pad_len,
-			RTE_CRYPTO_AUTH_OP_VERIFY,
-			tdata->validAuthLenInBits.len,
-			0);
+	retval = create_wireless_algo_cipher_operation_oop(
+					tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->validCipherLenInBits.len,
+					0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-				ut_params->op);
+						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->obuf = ut_params->op->sym->m_src;
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-				+ plaintext_pad_len;
 
-	/* Validate obuf */
-	if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
-		return 0;
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		return -1;
+		ciphertext = plaintext;
+
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		tdata->ciphertext.data,
+		tdata->validDataLenInBits.len,
+		"SNOW 3G Ciphertext data not as expected");
 	return 0;
 }
 
 static int
-test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
+test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
-	uint8_t *plaintext;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
+	uint8_t buffer[10000];
+	const uint8_t *ciphertext;
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
-			tdata->key.data, tdata->key.len,
-			0, tdata->digest.len,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			RTE_CRYPTO_AUTH_KASUMI_F9);
-	if (retval < 0)
-		return retval;
+	struct rte_cryptodev_info dev_info;
 
-	/* alloc mbuf and set payload */
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	rte_pktmbuf_tailroom(ut_params->ibuf));
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+	uint64_t feat_flags = dev_info.feature_flags;
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
-			NULL, 0,
-			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-			tdata->plaintext.len,
-			0);
+	if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
+		printf("Device doesn't support out-of-place scatter-gather "
+				"in both input and output mbufs. "
+				"Test Skipped.\n");
+		return -ENOTSUP;
+	}
+
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-				ut_params->op);
-	ut_params->obuf = ut_params->op->sym->m_src;
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-			+ plaintext_pad_len;
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-	ut_params->digest,
-	tdata->digest.data,
-	DIGEST_BYTE_LENGTH_KASUMI_F9,
-	"KASUMI Generated auth tag not as expected");
+	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 10, 0);
+	ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 3, 0);
+
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
+	TEST_ASSERT_NOT_NULL(ut_params->obuf,
+			"Failed to allocate output buffer in mempool");
+
+	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_cipher_operation_oop(
+					tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->validCipherLenInBits.len,
+					0);
+	if (retval < 0)
+		return retval;
+
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
+				plaintext_len, buffer);
+	else
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+				plaintext_len, buffer);
+
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		tdata->ciphertext.data,
+		tdata->validDataLenInBits.len,
+		"SNOW 3G Ciphertext data not as expected");
 
 	return 0;
 }
 
+/* Shift right a buffer by "offset" bits, "offset" < 8 */
+static void
+buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
+{
+	uint8_t curr_byte, prev_byte;
+	uint32_t length_in_bytes = ceil_byte_length(length + offset);
+	uint8_t lower_byte_mask = (1 << offset) - 1;
+	unsigned i;
+
+	prev_byte = buffer[0];
+	buffer[0] >>= offset;
+
+	for (i = 1; i < length_in_bytes; i++) {
+		curr_byte = buffer[i];
+		buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
+				(curr_byte >> offset);
+		prev_byte = curr_byte;
+	}
+}
+
 static int
-test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
+test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
-
+	uint8_t *plaintext, *ciphertext;
 	int retval;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
-	uint8_t *plaintext;
+	uint32_t plaintext_len;
+	uint32_t plaintext_pad_len;
+	uint8_t extra_offset = 4;
+	uint8_t *expected_ciphertext_shifted;
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
-				tdata->key.data, tdata->key.len,
-				0, tdata->digest.len,
-				RTE_CRYPTO_AUTH_OP_VERIFY,
-				RTE_CRYPTO_AUTH_KASUMI_F9);
+	/* QAT PMD supports byte-aligned data only */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))
+		return -ENOTSUP;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
-	/* alloc mbuf and set payload */
+
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
+	TEST_ASSERT_NOT_NULL(ut_params->obuf,
+			"Failed to allocate output buffer in mempool");
+
+	/* Clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	rte_pktmbuf_tailroom(ut_params->ibuf));
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
+	/*
+	 * Append data which is padded to a
+	 * multiple of the algorithms block size
+	 */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_hash_operation(tdata->digest.data,
-			tdata->digest.len,
-			NULL, 0,
-			plaintext_pad_len,
-			RTE_CRYPTO_AUTH_OP_VERIFY,
-			tdata->plaintext.len,
-			0);
+	plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
+						plaintext_pad_len);
+
+	rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
+
+	memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
+	buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
+
+#ifdef RTE_APP_TEST_DEBUG
+	rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
+#endif
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_cipher_operation_oop(
+					tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->validCipherLenInBits.len,
+					extra_offset);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-				ut_params->op);
+						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->obuf = ut_params->op->sym->m_src;
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-				+ plaintext_pad_len;
 
-	/* Validate obuf */
-	if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
-		return 0;
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		return -1;
+		ciphertext = plaintext;
 
-	return 0;
-}
+#ifdef RTE_APP_TEST_DEBUG
+	rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+#endif
 
-static int
-test_snow3g_hash_generate_test_case_1(void)
-{
-	return test_snow3g_authentication(&snow3g_hash_test_case_1);
-}
+	expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
 
-static int
-test_snow3g_hash_generate_test_case_2(void)
-{
-	return test_snow3g_authentication(&snow3g_hash_test_case_2);
-}
+	TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
+			"failed to reserve memory for ciphertext shifted\n");
 
-static int
-test_snow3g_hash_generate_test_case_3(void)
-{
-	return test_snow3g_authentication(&snow3g_hash_test_case_3);
+	memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
+			ceil_byte_length(tdata->ciphertext.len));
+	buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
+			extra_offset);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
+		ciphertext,
+		expected_ciphertext_shifted,
+		tdata->validDataLenInBits.len,
+		extra_offset,
+		"SNOW 3G Ciphertext data not as expected");
+	return 0;
 }
 
-static int
-test_snow3g_hash_generate_test_case_4(void)
+static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
 {
-	return test_snow3g_authentication(&snow3g_hash_test_case_4);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-static int
-test_snow3g_hash_generate_test_case_5(void)
-{
-	return test_snow3g_authentication(&snow3g_hash_test_case_5);
-}
+	int retval;
 
-static int
-test_snow3g_hash_generate_test_case_6(void)
-{
-	return test_snow3g_authentication(&snow3g_hash_test_case_6);
-}
+	uint8_t *plaintext, *ciphertext;
+	unsigned ciphertext_pad_len;
+	unsigned ciphertext_len;
 
-static int
-test_snow3g_hash_verify_test_case_1(void)
-{
-	return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-}
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+					RTE_CRYPTO_CIPHER_OP_DECRYPT,
+					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+					tdata->key.data, tdata->key.len,
+					tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
 
-static int
-test_snow3g_hash_verify_test_case_2(void)
-{
-	return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
-}
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-static int
-test_snow3g_hash_verify_test_case_3(void)
-{
-	return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
-}
+	/* Clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-static int
-test_snow3g_hash_verify_test_case_4(void)
-{
-	return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
-}
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
+	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				ciphertext_pad_len);
+	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-static int
-test_snow3g_hash_verify_test_case_5(void)
-{
-	return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
-}
-
-static int
-test_snow3g_hash_verify_test_case_6(void)
-{
-	return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
-}
-
-static int
-test_kasumi_hash_generate_test_case_1(void)
-{
-	return test_kasumi_authentication(&kasumi_hash_test_case_1);
-}
-
-static int
-test_kasumi_hash_generate_test_case_2(void)
-{
-	return test_kasumi_authentication(&kasumi_hash_test_case_2);
-}
-
-static int
-test_kasumi_hash_generate_test_case_3(void)
-{
-	return test_kasumi_authentication(&kasumi_hash_test_case_3);
-}
-
-static int
-test_kasumi_hash_generate_test_case_4(void)
-{
-	return test_kasumi_authentication(&kasumi_hash_test_case_4);
-}
-
-static int
-test_kasumi_hash_generate_test_case_5(void)
-{
-	return test_kasumi_authentication(&kasumi_hash_test_case_5);
-}
-
-static int
-test_kasumi_hash_generate_test_case_6(void)
-{
-	return test_kasumi_authentication(&kasumi_hash_test_case_6);
-}
-
-static int
-test_kasumi_hash_verify_test_case_1(void)
-{
-	return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
-}
+	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
-static int
-test_kasumi_hash_verify_test_case_2(void)
-{
-	return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
-}
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->validCipherLenInBits.len,
+					tdata->cipher.offset_bits);
+	if (retval < 0)
+		return retval;
 
-static int
-test_kasumi_hash_verify_test_case_3(void)
-{
-	return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
-}
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+						ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+	ut_params->obuf = ut_params->op->sym->m_dst;
+	if (ut_params->obuf)
+		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	else
+		plaintext = ciphertext;
 
-static int
-test_kasumi_hash_verify_test_case_4(void)
-{
-	return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
-}
+	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
-static int
-test_kasumi_hash_verify_test_case_5(void)
-{
-	return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
+				tdata->plaintext.data,
+				tdata->validDataLenInBits.len,
+				"SNOW 3G Plaintext data not as expected");
+	return 0;
 }
 
-static int
-test_kasumi_encryption(const struct kasumi_test_data *tdata)
+static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
+
 	uint8_t *plaintext, *ciphertext;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
+	unsigned ciphertext_pad_len;
+	unsigned ciphertext_len;
 
-	/* Create KASUMI session */
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create SNOW 3G session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_KASUMI_F8,
+					RTE_CRYPTO_CIPHER_OP_DECRYPT,
+					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 					tdata->key.data, tdata->key.len,
 					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer");
+	TEST_ASSERT_NOT_NULL(ut_params->obuf,
+			"Failed to allocate output buffer");
 
 	/* Clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+	memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
+		       rte_pktmbuf_tailroom(ut_params->obuf));
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
+	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				ciphertext_pad_len);
+	rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
+	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-				tdata->cipher_iv.len,
-				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
-				tdata->validCipherOffsetInBits.len);
+	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
+
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
+					tdata->cipher_iv.len,
+					tdata->validCipherLenInBits.len,
+					0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-
 	ut_params->obuf = ut_params->op->sym->m_dst;
 	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
+		plaintext = ciphertext;
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
-	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		reference_ciphertext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Ciphertext data not as expected");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
+				tdata->plaintext.data,
+				tdata->validDataLenInBits.len,
+				"SNOW 3G Plaintext data not as expected");
 	return 0;
 }
 
 static int
-test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
+test_zuc_cipher_auth(const struct wireless_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
 
+	uint8_t *plaintext, *ciphertext;
 	unsigned int plaintext_pad_len;
 	unsigned int plaintext_len;
 
-	uint8_t buffer[10000];
-	const uint8_t *ciphertext;
+	struct rte_cryptodev_sym_capability_idx cap_idx;
 
-	struct rte_cryptodev_info dev_info;
+	/* Check if device supports ZUC EEA3 */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	uint64_t feat_flags = dev_info.feature_flags;
+	/* Check if device supports ZUC EIA3 */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
 
-	if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
-		printf("Device doesn't support in-place scatter-gather. "
-				"Test Skipped.\n");
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
 		return -ENOTSUP;
-	}
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_KASUMI_F8,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
+	/* Create ZUC session */
+	retval = create_zuc_cipher_auth_encrypt_generate_session(
+			ts_params->valid_devs[0],
+			tdata);
 	if (retval < 0)
 		return retval;
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-
-
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 10, 0);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-				tdata->cipher_iv.len,
-				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
-				tdata->validCipherOffsetInBits.len);
+	/* Create ZUC operation */
+	retval = create_zuc_cipher_hash_generate_operation(tdata);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
+			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-
-	ut_params->obuf = ut_params->op->sym->m_dst;
-
+	ut_params->obuf = ut_params->op->sym->m_src;
 	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
-				plaintext_len, buffer);
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
-				tdata->validCipherOffsetInBits.len >> 3,
-				plaintext_len, buffer);
+		ciphertext = plaintext;
 
-	/* Validate obuf */
 	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
-
-	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		reference_ciphertext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Ciphertext data not as expected");
-	return 0;
-}
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->validDataLenInBits.len,
+			"ZUC Ciphertext data not as expected");
 
-static int
-test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+	    + plaintext_pad_len;
+
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			ut_params->digest,
+			tdata->digest.data,
+			4,
+			"ZUC Generated auth tag not as expected");
+	return 0;
+}
+
+static int
+test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
+
 	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_KASUMI_F8,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_cipher_auth_session(
+			ts_params->valid_devs[0],
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+			tdata->key.data, tdata->key.len,
+			tdata->auth_iv.len, tdata->digest.len,
+			tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
-
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* Clear mbuf payload */
+	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 				plaintext_pad_len);
-	rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
 	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
 	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-				tdata->cipher_iv.len,
-				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
-				tdata->validCipherOffsetInBits.len);
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
+			tdata->digest.len, tdata->auth_iv.data,
+			tdata->auth_iv.len,
+			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+			tdata->cipher_iv.data, tdata->cipher_iv.len,
+			tdata->validCipherLenInBits.len,
+			0,
+			tdata->validAuthLenInBits.len,
+			0
+			);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
+			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-
-	ut_params->obuf = ut_params->op->sym->m_dst;
+	ut_params->obuf = ut_params->op->sym->m_src;
 	if (ut_params->obuf)
 		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
+		ciphertext = plaintext;
 
 	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
-
-	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		reference_ciphertext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Ciphertext data not as expected");
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->validDataLenInBits.len,
+			"SNOW 3G Ciphertext data not as expected");
+
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+	    + plaintext_pad_len;
+
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			ut_params->digest,
+			tdata->digest.data,
+			DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
+			"SNOW 3G Generated auth tag not as expected");
 	return 0;
 }
 
 static int
-test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
+test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
+	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
+
+	uint8_t *plaintext = NULL, *ciphertext = NULL;
 	unsigned int plaintext_pad_len;
 	unsigned int plaintext_len;
-
-	const uint8_t *ciphertext;
-	uint8_t buffer[2048];
+	unsigned int ciphertext_pad_len;
+	unsigned int ciphertext_len;
 
 	struct rte_cryptodev_info dev_info;
 
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
 	uint64_t feat_flags = dev_info.feature_flags;
-	if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
-		printf("Device doesn't support out-of-place scatter-gather "
-				"in both input and output mbufs. "
-				"Test Skipped.\n");
-		return -ENOTSUP;
+
+	if (op_mode == OUT_OF_PLACE) {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+			printf("Device doesn't support digest encrypted.\n");
+			return -ENOTSUP;
+		}
 	}
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_KASUMI_F8,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_auth_cipher_session(
+			ts_params->valid_devs[0],
+			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
+					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
+			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
+					: RTE_CRYPTO_AUTH_OP_GENERATE),
+			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+			tdata->key.data, tdata->key.len,
+			tdata->auth_iv.len, tdata->digest.len,
+			tdata->cipher_iv.len);
+
 	if (retval < 0)
 		return retval;
 
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	if (op_mode == OUT_OF_PLACE)
+		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+		rte_pktmbuf_tailroom(ut_params->ibuf));
+	if (op_mode == OUT_OF_PLACE)
+		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->obuf));
+
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
-	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 10, 0);
-	ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 3, 0);
+	if (verify) {
+		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+					ciphertext_pad_len);
+		memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
+		if (op_mode == OUT_OF_PLACE)
+			rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+	} else {
+		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+					plaintext_pad_len);
+		memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+		if (op_mode == OUT_OF_PLACE)
+			rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
+		debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+	}
 
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_auth_cipher_operation(
+		tdata->digest.len,
+		tdata->cipher_iv.data, tdata->cipher_iv.len,
+		tdata->auth_iv.data, tdata->auth_iv.len,
+		(tdata->digest.offset_bytes == 0 ?
+		(verify ? ciphertext_pad_len : plaintext_pad_len)
+			: tdata->digest.offset_bytes),
+		tdata->validCipherLenInBits.len,
+		tdata->cipher.offset_bits,
+		tdata->validAuthLenInBits.len,
+		tdata->auth.offset_bits,
+		op_mode, 0);
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-				tdata->cipher_iv.len,
-				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
-				tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
+			ut_params->op);
+
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
-				plaintext_pad_len, buffer);
-	else
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
-				tdata->validCipherOffsetInBits.len >> 3,
-				plaintext_pad_len, buffer);
+	ut_params->obuf = (op_mode == IN_PLACE ?
+		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
-	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		reference_ciphertext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Ciphertext data not as expected");
-	return 0;
-}
+	if (verify) {
+		if (ut_params->obuf)
+			plaintext = rte_pktmbuf_mtod(ut_params->obuf,
+							uint8_t *);
+		else
+			plaintext = ciphertext +
+				(tdata->cipher.offset_bits >> 3);
 
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+		debug_hexdump(stdout, "plaintext expected:",
+			tdata->plaintext.data,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+	} else {
+		if (ut_params->obuf)
+			ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
+							uint8_t *);
+		else
+			ciphertext = plaintext;
 
-static int
-test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+		debug_hexdump(stdout, "ciphertext expected:",
+			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
 
-	int retval;
-	uint8_t *ciphertext, *plaintext;
-	unsigned ciphertext_pad_len;
-	unsigned ciphertext_len;
-
-	/* Create KASUMI session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_DECRYPT,
-					RTE_CRYPTO_CIPHER_KASUMI_F8,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
-
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-
-	/* Clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
-
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
-	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				ciphertext_pad_len);
-	rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
-	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
-
-	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
-
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-				tdata->cipher_iv.len,
-				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
-				tdata->validCipherOffsetInBits.len);
-	if (retval < 0)
-		return retval;
-
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
+		ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+			+ (tdata->digest.offset_bytes == 0 ?
+		plaintext_pad_len : tdata->digest.offset_bytes);
 
-	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
+		debug_hexdump(stdout, "digest:", ut_params->digest,
+			tdata->digest.len);
+		debug_hexdump(stdout, "digest expected:", tdata->digest.data,
+				tdata->digest.len);
+	}
 
-	const uint8_t *reference_plaintext = tdata->plaintext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		plaintext,
-		reference_plaintext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Plaintext data not as expected");
+	if (verify) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len >> 3,
+			"SNOW 3G Plaintext data not as expected");
+	} else {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->validDataLenInBits.len,
+			"SNOW 3G Ciphertext data not as expected");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			ut_params->digest,
+			tdata->digest.data,
+			DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
+			"SNOW 3G Generated auth tag not as expected");
+	}
 	return 0;
 }
 
 static int
-test_kasumi_decryption(const struct kasumi_test_data *tdata)
+test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
+	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
-	uint8_t *ciphertext, *plaintext;
-	unsigned ciphertext_pad_len;
-	unsigned ciphertext_len;
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_DECRYPT,
-					RTE_CRYPTO_CIPHER_KASUMI_F8,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
+	const uint8_t *plaintext = NULL;
+	const uint8_t *ciphertext = NULL;
+	const uint8_t *digest = NULL;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
+	unsigned int ciphertext_pad_len;
+	unsigned int ciphertext_len;
+	uint8_t buffer[10000];
+	uint8_t digest_buffer[10000];
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	struct rte_cryptodev_info dev_info;
 
-	/* Clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
-	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				ciphertext_pad_len);
-	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if (op_mode == IN_PLACE) {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
+			printf("Device doesn't support in-place scatter-gather "
+					"in both input and output mbufs.\n");
+			return -ENOTSUP;
+		}
+	} else {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
+			printf("Device doesn't support out-of-place scatter-gather "
+					"in both input and output mbufs.\n");
+			return -ENOTSUP;
+		}
+		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+			printf("Device doesn't support digest encrypted.\n");
+			return -ENOTSUP;
+		}
+	}
+
+	/* Create SNOW 3G session */
+	retval = create_wireless_algo_auth_cipher_session(
+			ts_params->valid_devs[0],
+			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
+					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
+			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
+					: RTE_CRYPTO_AUTH_OP_GENERATE),
+			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+			tdata->key.data, tdata->key.len,
+			tdata->auth_iv.len, tdata->digest.len,
+			tdata->cipher_iv.len);
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->ciphertext.len,
-					tdata->validCipherOffsetInBits.len);
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
-	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
+	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 15, 0);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
 
-	const uint8_t *reference_plaintext = tdata->plaintext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		plaintext,
-		reference_plaintext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Plaintext data not as expected");
-	return 0;
-}
+	if (op_mode == OUT_OF_PLACE) {
+		ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
+				plaintext_pad_len, 15, 0);
+		TEST_ASSERT_NOT_NULL(ut_params->obuf,
+				"Failed to allocate output buffer in mempool");
+	}
 
-static int
-test_snow3g_encryption(const struct snow3g_test_data *tdata)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	if (verify) {
+		pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
+			tdata->ciphertext.data);
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					ciphertext_len, buffer);
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+	} else {
+		pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
+			tdata->plaintext.data);
+		plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					plaintext_len, buffer);
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			plaintext_len);
+	}
+	memset(buffer, 0, sizeof(buffer));
 
-	int retval;
-	uint8_t *plaintext, *ciphertext;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
+	/* Create SNOW 3G operation */
+	retval = create_wireless_algo_auth_cipher_operation(
+		tdata->digest.len,
+		tdata->cipher_iv.data, tdata->cipher_iv.len,
+		tdata->auth_iv.data, tdata->auth_iv.len,
+		(tdata->digest.offset_bytes == 0 ?
+		(verify ? ciphertext_pad_len : plaintext_pad_len)
+			: tdata->digest.offset_bytes),
+		tdata->validCipherLenInBits.len,
+		tdata->cipher.offset_bits,
+		tdata->validAuthLenInBits.len,
+		tdata->auth.offset_bits,
+		op_mode, 1);
 
-	/* Create SNOW 3G session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
 
-	/* Clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+	ut_params->obuf = (op_mode == IN_PLACE ?
+		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+	if (verify) {
+		if (ut_params->obuf)
+			plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
+					plaintext_len, buffer);
+		else
+			plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					plaintext_len, buffer);
 
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->validCipherLenInBits.len,
-					0);
-	if (retval < 0)
-		return retval;
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+		debug_hexdump(stdout, "plaintext expected:",
+			tdata->plaintext.data,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+	} else {
+		if (ut_params->obuf)
+			ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
+					ciphertext_len, buffer);
+		else
+			ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					ciphertext_len, buffer);
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+		debug_hexdump(stdout, "ciphertext expected:",
+			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
 
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		ciphertext = plaintext;
+		if (ut_params->obuf)
+			digest = rte_pktmbuf_read(ut_params->obuf,
+				(tdata->digest.offset_bytes == 0 ?
+				plaintext_pad_len : tdata->digest.offset_bytes),
+				tdata->digest.len, digest_buffer);
+		else
+			digest = rte_pktmbuf_read(ut_params->ibuf,
+				(tdata->digest.offset_bytes == 0 ?
+				plaintext_pad_len : tdata->digest.offset_bytes),
+				tdata->digest.len, digest_buffer);
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+		debug_hexdump(stdout, "digest:", digest,
+			tdata->digest.len);
+		debug_hexdump(stdout, "digest expected:",
+			tdata->digest.data, tdata->digest.len);
+	}
 
 	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		tdata->ciphertext.data,
-		tdata->validDataLenInBits.len,
-		"SNOW 3G Ciphertext data not as expected");
+	if (verify) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len >> 3,
+			"SNOW 3G Plaintext data not as expected");
+	} else {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->validDataLenInBits.len,
+			"SNOW 3G Ciphertext data not as expected");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			digest,
+			tdata->digest.data,
+			DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
+			"SNOW 3G Generated auth tag not as expected");
+	}
 	return 0;
 }
 
-
 static int
-test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
+test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
+	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
-	uint8_t *plaintext, *ciphertext;
 
 	int retval;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
 
-	/* Create SNOW 3G session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
+	uint8_t *plaintext = NULL, *ciphertext = NULL;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
+	unsigned int ciphertext_pad_len;
+	unsigned int ciphertext_len;
+
+	struct rte_cryptodev_info dev_info;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if (op_mode == OUT_OF_PLACE) {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+			printf("Device doesn't support digest encrypted.\n");
+			return -ENOTSUP;
+		}
+	}
+
+	/* Create KASUMI session */
+	retval = create_wireless_algo_auth_cipher_session(
+			ts_params->valid_devs[0],
+			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
+					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
+			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
+					: RTE_CRYPTO_AUTH_OP_GENERATE),
+			RTE_CRYPTO_AUTH_KASUMI_F9,
+			RTE_CRYPTO_CIPHER_KASUMI_F8,
+			tdata->key.data, tdata->key.len,
+			0, tdata->digest.len,
+			tdata->cipher_iv.len);
+
 	if (retval < 0)
 		return retval;
 
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
-	TEST_ASSERT_NOT_NULL(ut_params->obuf,
-			"Failed to allocate output buffer in mempool");
+	if (op_mode == OUT_OF_PLACE)
+		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* Clear mbuf payload */
+	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
+		rte_pktmbuf_tailroom(ut_params->ibuf));
+	if (op_mode == OUT_OF_PLACE)
+		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->obuf));
 
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
 	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+	if (verify) {
+		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+					ciphertext_pad_len);
+		memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
+		if (op_mode == OUT_OF_PLACE)
+			rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+	} else {
+		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+					plaintext_pad_len);
+		memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+		if (op_mode == OUT_OF_PLACE)
+			rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			plaintext_len);
+	}
+
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_auth_cipher_operation(
+		tdata->digest.len,
+		tdata->cipher_iv.data, tdata->cipher_iv.len,
+		NULL, 0,
+		(tdata->digest.offset_bytes == 0 ?
+		(verify ? ciphertext_pad_len : plaintext_pad_len)
+			: tdata->digest.offset_bytes),
+		tdata->validCipherLenInBits.len,
+		tdata->validCipherOffsetInBits.len,
+		tdata->validAuthLenInBits.len,
+		0,
+		op_mode, 0);
 
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->validCipherLenInBits.len,
-					0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		ciphertext = plaintext;
+			ut_params->op);
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		tdata->ciphertext.data,
-		tdata->validDataLenInBits.len,
-		"SNOW 3G Ciphertext data not as expected");
-	return 0;
-}
+	ut_params->obuf = (op_mode == IN_PLACE ?
+		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
-static int
-test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	int retval;
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	uint8_t buffer[10000];
-	const uint8_t *ciphertext;
+	if (verify) {
+		if (ut_params->obuf)
+			plaintext = rte_pktmbuf_mtod(ut_params->obuf,
+							uint8_t *);
+		else
+			plaintext = ciphertext;
 
-	struct rte_cryptodev_info dev_info;
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+		debug_hexdump(stdout, "plaintext expected:",
+			tdata->plaintext.data,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+	} else {
+		if (ut_params->obuf)
+			ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
+							uint8_t *);
+		else
+			ciphertext = plaintext;
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+		debug_hexdump(stdout, "ciphertext expected:",
+			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
 
-	uint64_t feat_flags = dev_info.feature_flags;
+		ut_params->digest = rte_pktmbuf_mtod(
+			ut_params->obuf, uint8_t *) +
+			(tdata->digest.offset_bytes == 0 ?
+			plaintext_pad_len : tdata->digest.offset_bytes);
 
-	if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
-		printf("Device doesn't support out-of-place scatter-gather "
-				"in both input and output mbufs. "
-				"Test Skipped.\n");
+		debug_hexdump(stdout, "digest:", ut_params->digest,
+			tdata->digest.len);
+		debug_hexdump(stdout, "digest expected:",
+			tdata->digest.data, tdata->digest.len);
+	}
+
+	/* Validate obuf */
+	if (verify) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len >> 3,
+			"KASUMI Plaintext data not as expected");
+	} else {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->ciphertext.len >> 3,
+			"KASUMI Ciphertext data not as expected");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			ut_params->digest,
+			tdata->digest.data,
+			DIGEST_BYTE_LENGTH_KASUMI_F9,
+			"KASUMI Generated auth tag not as expected");
+	}
+	return 0;
+}
+
+static int
+test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
+	uint8_t op_mode, uint8_t verify)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+
+	int retval;
+
+	const uint8_t *plaintext = NULL;
+	const uint8_t *ciphertext = NULL;
+	const uint8_t *digest = NULL;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
+	unsigned int ciphertext_pad_len;
+	unsigned int ciphertext_len;
+	uint8_t buffer[10000];
+	uint8_t digest_buffer[10000];
+
+	struct rte_cryptodev_info dev_info;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
 		return -ENOTSUP;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if (op_mode == IN_PLACE) {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
+			printf("Device doesn't support in-place scatter-gather "
+					"in both input and output mbufs.\n");
+			return -ENOTSUP;
+		}
+	} else {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
+			printf("Device doesn't support out-of-place scatter-gather "
+					"in both input and output mbufs.\n");
+			return -ENOTSUP;
+		}
+		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+			printf("Device doesn't support digest encrypted.\n");
+			return -ENOTSUP;
+		}
 	}
 
-	/* Create SNOW 3G session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
+	/* Create KASUMI session */
+	retval = create_wireless_algo_auth_cipher_session(
+			ts_params->valid_devs[0],
+			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
+					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
+			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
+					: RTE_CRYPTO_AUTH_OP_GENERATE),
+			RTE_CRYPTO_AUTH_KASUMI_F9,
+			RTE_CRYPTO_CIPHER_KASUMI_F8,
+			tdata->key.data, tdata->key.len,
+			0, tdata->digest.len,
+			tdata->cipher_iv.len);
+
 	if (retval < 0)
 		return retval;
 
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
 	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
 	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 10, 0);
-	ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 3, 0);
-
+			plaintext_pad_len, 15, 0);
 	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
 			"Failed to allocate input buffer in mempool");
-	TEST_ASSERT_NOT_NULL(ut_params->obuf,
-			"Failed to allocate output buffer in mempool");
 
-	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+	if (op_mode == OUT_OF_PLACE) {
+		ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
+				plaintext_pad_len, 15, 0);
+		TEST_ASSERT_NOT_NULL(ut_params->obuf,
+				"Failed to allocate output buffer in mempool");
+	}
+
+	if (verify) {
+		pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
+			tdata->ciphertext.data);
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					ciphertext_len, buffer);
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+	} else {
+		pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
+			tdata->plaintext.data);
+		plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					plaintext_len, buffer);
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			plaintext_len);
+	}
+	memset(buffer, 0, sizeof(buffer));
+
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_auth_cipher_operation(
+		tdata->digest.len,
+		tdata->cipher_iv.data, tdata->cipher_iv.len,
+		NULL, 0,
+		(tdata->digest.offset_bytes == 0 ?
+		(verify ? ciphertext_pad_len : plaintext_pad_len)
+			: tdata->digest.offset_bytes),
+		tdata->validCipherLenInBits.len,
+		tdata->validCipherOffsetInBits.len,
+		tdata->validAuthLenInBits.len,
+		0,
+		op_mode, 1);
 
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->validCipherLenInBits.len,
-					0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
+			ut_params->op);
+
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
-				plaintext_len, buffer);
-	else
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
-				plaintext_len, buffer);
+	ut_params->obuf = (op_mode == IN_PLACE ?
+		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+	if (verify) {
+		if (ut_params->obuf)
+			plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
+					plaintext_len, buffer);
+		else
+			plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					plaintext_len, buffer);
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		tdata->ciphertext.data,
-		tdata->validDataLenInBits.len,
-		"SNOW 3G Ciphertext data not as expected");
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+		debug_hexdump(stdout, "plaintext expected:",
+			tdata->plaintext.data,
+			(tdata->plaintext.len >> 3) - tdata->digest.len);
+	} else {
+		if (ut_params->obuf)
+			ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
+					ciphertext_len, buffer);
+		else
+			ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+					ciphertext_len, buffer);
 
-	return 0;
-}
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+			ciphertext_len);
+		debug_hexdump(stdout, "ciphertext expected:",
+			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
 
-/* Shift right a buffer by "offset" bits, "offset" < 8 */
-static void
-buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
-{
-	uint8_t curr_byte, prev_byte;
-	uint32_t length_in_bytes = ceil_byte_length(length + offset);
-	uint8_t lower_byte_mask = (1 << offset) - 1;
-	unsigned i;
+		if (ut_params->obuf)
+			digest = rte_pktmbuf_read(ut_params->obuf,
+				(tdata->digest.offset_bytes == 0 ?
+				plaintext_pad_len : tdata->digest.offset_bytes),
+				tdata->digest.len, digest_buffer);
+		else
+			digest = rte_pktmbuf_read(ut_params->ibuf,
+				(tdata->digest.offset_bytes == 0 ?
+				plaintext_pad_len : tdata->digest.offset_bytes),
+				tdata->digest.len, digest_buffer);
 
-	prev_byte = buffer[0];
-	buffer[0] >>= offset;
+		debug_hexdump(stdout, "digest:", digest,
+			tdata->digest.len);
+		debug_hexdump(stdout, "digest expected:",
+			tdata->digest.data, tdata->digest.len);
+	}
 
-	for (i = 1; i < length_in_bytes; i++) {
-		curr_byte = buffer[i];
-		buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
-				(curr_byte >> offset);
-		prev_byte = curr_byte;
+	/* Validate obuf */
+	if (verify) {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len >> 3,
+			"KASUMI Plaintext data not as expected");
+	} else {
+		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->validDataLenInBits.len,
+			"KASUMI Ciphertext data not as expected");
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			digest,
+			tdata->digest.data,
+			DIGEST_BYTE_LENGTH_KASUMI_F9,
+			"KASUMI Generated auth tag not as expected");
 	}
+	return 0;
 }
 
 static int
-test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
+test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
-	uint8_t *plaintext, *ciphertext;
+
 	int retval;
-	uint32_t plaintext_len;
-	uint32_t plaintext_pad_len;
-	uint8_t extra_offset = 4;
-	uint8_t *expected_ciphertext_shifted;
 
-	/* Create SNOW 3G session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
+	uint8_t *plaintext, *ciphertext;
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create KASUMI session */
+	retval = create_wireless_algo_cipher_auth_session(
+			ts_params->valid_devs[0],
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			RTE_CRYPTO_AUTH_KASUMI_F9,
+			RTE_CRYPTO_CIPHER_KASUMI_F8,
+			tdata->key.data, tdata->key.len,
+			0, tdata->digest.len,
+			tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
-	TEST_ASSERT_NOT_NULL(ut_params->obuf,
-			"Failed to allocate output buffer in mempool");
-
-	/* Clear mbuf payload */
+	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
-	/*
-	 * Append data which is padded to a
-	 * multiple of the algorithms block size
-	 */
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple of */
+	/* the algorithms block size */
 	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
-						plaintext_pad_len);
-
-	rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
-
-	memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
-	buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
-#ifdef RTE_APP_TEST_DEBUG
-	rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
-#endif
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->validCipherLenInBits.len,
-					extra_offset);
+	/* Create KASUMI operation */
+	retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
+				tdata->digest.len, NULL, 0,
+				plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
+				tdata->cipher_iv.data, tdata->cipher_iv.len,
+				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len,
+					8),
+				tdata->validCipherOffsetInBits.len,
+				tdata->validAuthLenInBits.len,
+				0
+				);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
+			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+	if (ut_params->op->sym->m_dst)
+		ut_params->obuf = ut_params->op->sym->m_dst;
 	else
-		ciphertext = plaintext;
-
-#ifdef RTE_APP_TEST_DEBUG
-	rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
-#endif
+		ut_params->obuf = ut_params->op->sym->m_src;
 
-	expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
+	ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+				tdata->validCipherOffsetInBits.len >> 3);
 
-	TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
-			"failed to reserve memory for ciphertext shifted\n");
+	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+			+ plaintext_pad_len;
 
-	memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
-			ceil_byte_length(tdata->ciphertext.len));
-	buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
-			extra_offset);
+	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+				(tdata->validCipherOffsetInBits.len >> 3);
 	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 		ciphertext,
-		expected_ciphertext_shifted,
-		tdata->validDataLenInBits.len,
-		extra_offset,
-		"SNOW 3G Ciphertext data not as expected");
+		reference_ciphertext,
+		tdata->validCipherLenInBits.len,
+		"KASUMI Ciphertext data not as expected");
+
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+		ut_params->digest,
+		tdata->digest.data,
+		DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
+		"KASUMI Generated auth tag not as expected");
 	return 0;
 }
 
-static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
+static int
+test_zuc_encryption(const struct wireless_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
-
 	uint8_t *plaintext, *ciphertext;
-	unsigned ciphertext_pad_len;
-	unsigned ciphertext_len;
-
-	/* Create SNOW 3G session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_DECRYPT,
-					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
-
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-
-	/* Clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
-
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				ciphertext_pad_len);
-	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
-
-	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
-
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->validCipherLenInBits.len,
-					tdata->cipher.offset_bits);
-	if (retval < 0)
-		return retval;
-
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		plaintext = ciphertext;
-
-	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
-
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
-				tdata->plaintext.data,
-				tdata->validDataLenInBits.len,
-				"SNOW 3G Plaintext data not as expected");
-	return 0;
-}
+	unsigned plaintext_pad_len;
+	unsigned plaintext_len;
 
-static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct rte_cryptodev_sym_capability_idx cap_idx;
 
-	int retval;
+	/* Check if device supports ZUC EEA3 */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
 
-	uint8_t *plaintext, *ciphertext;
-	unsigned ciphertext_pad_len;
-	unsigned ciphertext_len;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* Create SNOW 3G session */
+	/* Create ZUC session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_DECRYPT,
-					RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+					RTE_CRYPTO_CIPHER_ZUC_EEA3,
 					tdata->key.data, tdata->key.len,
 					tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer");
-	TEST_ASSERT_NOT_NULL(ut_params->obuf,
-			"Failed to allocate output buffer");
 
 	/* Clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 	       rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
-		       rte_pktmbuf_tailroom(ut_params->obuf));
-
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				ciphertext_pad_len);
-	rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
-	memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
+	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
+	/* Create ZUC operation */
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
 					tdata->cipher_iv.len,
-					tdata->validCipherLenInBits.len,
+					tdata->plaintext.len,
 					0);
 	if (retval < 0)
 		return retval;
@@ -4419,33 +4855,37 @@  static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+
 	ut_params->obuf = ut_params->op->sym->m_dst;
 	if (ut_params->obuf)
-		plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
 	else
-		plaintext = ciphertext;
+		ciphertext = plaintext;
 
-	debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
+	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
 	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
-				tdata->plaintext.data,
-				tdata->validDataLenInBits.len,
-				"SNOW 3G Plaintext data not as expected");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+		ciphertext,
+		tdata->ciphertext.data,
+		tdata->validCipherLenInBits.len,
+		"ZUC Ciphertext data not as expected");
 	return 0;
 }
 
 static int
-test_zuc_cipher_auth(const struct wireless_test_data *tdata)
+test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
 
-	uint8_t *plaintext, *ciphertext;
 	unsigned int plaintext_pad_len;
 	unsigned int plaintext_len;
+	const uint8_t *ciphertext;
+	uint8_t ciphertext_buffer[2048];
+	struct rte_cryptodev_info dev_info;
 
 	struct rte_cryptodev_sym_capability_idx cap_idx;
 
@@ -4457,154 +4897,151 @@  test_zuc_cipher_auth(const struct wireless_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
-	/* Check if device supports ZUC EIA3 */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-			&cap_idx) == NULL)
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
+		printf("Device doesn't support in-place scatter-gather. "
+				"Test Skipped.\n");
 		return -ENOTSUP;
+	}
+
+	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+
+	/* Append data which is padded to a multiple */
+	/* of the algorithms block size */
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+
+	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			plaintext_pad_len, 10, 0);
+
+	pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
+			tdata->plaintext.data);
 
 	/* Create ZUC session */
-	retval = create_zuc_cipher_auth_encrypt_generate_session(
-			ts_params->valid_devs[0],
-			tdata);
+	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_CIPHER_ZUC_EEA3,
+			tdata->key.data, tdata->key.len,
+			tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+	/* Clear mbuf payload */
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
 
 	/* Create ZUC operation */
-	retval = create_zuc_cipher_hash_generate_operation(tdata);
+	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
+			tdata->cipher_iv.len, tdata->plaintext.len,
+			0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->obuf = ut_params->op->sym->m_src;
+
+	ut_params->obuf = ut_params->op->sym->m_dst;
 	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+		ciphertext = rte_pktmbuf_read(ut_params->obuf,
+			0, plaintext_len, ciphertext_buffer);
 	else
-		ciphertext = plaintext;
+		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+			0, plaintext_len, ciphertext_buffer);
 
+	/* Validate obuf */
 	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->validDataLenInBits.len,
-			"ZUC Ciphertext data not as expected");
-
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-	    + plaintext_pad_len;
+		ciphertext,
+		tdata->ciphertext.data,
+		tdata->validCipherLenInBits.len,
+		"ZUC Ciphertext data not as expected");
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ut_params->digest,
-			tdata->digest.data,
-			4,
-			"ZUC Generated auth tag not as expected");
 	return 0;
 }
 
 static int
-test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
+test_zuc_authentication(const struct wireless_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
-
-	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
+	uint8_t *plaintext;
 
-	/* Create SNOW 3G session */
-	retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
-			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+
+	/* QAT PMD supports byte-aligned data only */
+	if ((tdata->validAuthLenInBits.len % 8 != 0) &&
+			(gbl_driver_id == rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))))
+		return -ENOTSUP;
+
+	/* Check if device supports ZUC EIA3 */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create ZUC session */
+	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
 			tdata->key.data, tdata->key.len,
 			tdata->auth_iv.len, tdata->digest.len,
-			tdata->cipher_iv.len);
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			RTE_CRYPTO_AUTH_ZUC_EIA3);
 	if (retval < 0)
 		return retval;
+
+	/* alloc mbuf and set payload */
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+	rte_pktmbuf_tailroom(ut_params->ibuf));
 
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
 	/* Append data which is padded to a multiple of */
 	/* the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
 	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
 				plaintext_pad_len);
 	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
-
-	/* Create SNOW 3G operation */
-	retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
-			tdata->digest.len, tdata->auth_iv.data,
-			tdata->auth_iv.len,
+	/* Create ZUC operation */
+	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
+			tdata->auth_iv.data, tdata->auth_iv.len,
 			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-			tdata->cipher_iv.data, tdata->cipher_iv.len,
-			tdata->validCipherLenInBits.len,
-			0,
 			tdata->validAuthLenInBits.len,
-			0
-			);
+			0);
 	if (retval < 0)
 		return retval;
 
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+				ut_params->op);
 	ut_params->obuf = ut_params->op->sym->m_src;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		ciphertext = plaintext;
-
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->validDataLenInBits.len,
-			"SNOW 3G Ciphertext data not as expected");
-
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-	    + plaintext_pad_len;
+			+ plaintext_pad_len;
 
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ut_params->digest,
-			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
-			"SNOW 3G Generated auth tag not as expected");
+	ut_params->digest,
+	tdata->digest.data,
+	tdata->digest.len,
+	"ZUC Generated auth tag not as expected");
+
 	return 0;
 }
 
 static int
-test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
+test_zuc_auth_cipher(const struct wireless_test_data *tdata,
 	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
@@ -4619,6 +5056,15 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 	unsigned int ciphertext_len;
 
 	struct rte_cryptodev_info dev_info;
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+
+	/* Check if device supports ZUC EIA3 */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
@@ -4631,15 +5077,15 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 		}
 	}
 
-	/* Create SNOW 3G session */
+	/* Create ZUC session */
 	retval = create_wireless_algo_auth_cipher_session(
 			ts_params->valid_devs[0],
 			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
 					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
 			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
 					: RTE_CRYPTO_AUTH_OP_GENERATE),
-			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
-			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+			RTE_CRYPTO_AUTH_ZUC_EIA3,
+			RTE_CRYPTO_CIPHER_ZUC_EEA3,
 			tdata->key.data, tdata->key.len,
 			tdata->auth_iv.len, tdata->digest.len,
 			tdata->cipher_iv.len);
@@ -4677,10 +5123,11 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 		memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 		if (op_mode == OUT_OF_PLACE)
 			rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
-		debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+		debug_hexdump(stdout, "plaintext:", plaintext,
+			plaintext_len);
 	}
 
-	/* Create SNOW 3G operation */
+	/* Create ZUC operation */
 	retval = create_wireless_algo_auth_cipher_operation(
 		tdata->digest.len,
 		tdata->cipher_iv.data, tdata->cipher_iv.len,
@@ -4689,9 +5136,9 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 		(verify ? ciphertext_pad_len : plaintext_pad_len)
 			: tdata->digest.offset_bytes),
 		tdata->validCipherLenInBits.len,
-		tdata->cipher.offset_bits,
+		tdata->validCipherOffsetInBits.len,
 		tdata->validAuthLenInBits.len,
-		tdata->auth.offset_bits,
+		0,
 		op_mode, 0);
 
 	if (retval < 0)
@@ -4705,13 +5152,13 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 	ut_params->obuf = (op_mode == IN_PLACE ?
 		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
+
 	if (verify) {
 		if (ut_params->obuf)
 			plaintext = rte_pktmbuf_mtod(ut_params->obuf,
 							uint8_t *);
 		else
-			plaintext = ciphertext +
-				(tdata->cipher.offset_bits >> 3);
+			plaintext = ciphertext;
 
 		debug_hexdump(stdout, "plaintext:", plaintext,
 			(tdata->plaintext.len >> 3) - tdata->digest.len);
@@ -4730,14 +5177,15 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 		debug_hexdump(stdout, "ciphertext expected:",
 			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
 
-		ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-			+ (tdata->digest.offset_bytes == 0 ?
-		plaintext_pad_len : tdata->digest.offset_bytes);
+		ut_params->digest = rte_pktmbuf_mtod(
+			ut_params->obuf, uint8_t *) +
+			(tdata->digest.offset_bytes == 0 ?
+			plaintext_pad_len : tdata->digest.offset_bytes);
 
 		debug_hexdump(stdout, "digest:", ut_params->digest,
 			tdata->digest.len);
-		debug_hexdump(stdout, "digest expected:", tdata->digest.data,
-				tdata->digest.len);
+		debug_hexdump(stdout, "digest expected:",
+			tdata->digest.data, tdata->digest.len);
 	}
 
 	/* Validate obuf */
@@ -4746,25 +5194,25 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 			plaintext,
 			tdata->plaintext.data,
 			tdata->plaintext.len >> 3,
-			"SNOW 3G Plaintext data not as expected");
+			"ZUC Plaintext data not as expected");
 	} else {
 		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 			ciphertext,
 			tdata->ciphertext.data,
-			tdata->validDataLenInBits.len,
-			"SNOW 3G Ciphertext data not as expected");
+			tdata->ciphertext.len >> 3,
+			"ZUC Ciphertext data not as expected");
 
 		TEST_ASSERT_BUFFERS_ARE_EQUAL(
 			ut_params->digest,
 			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
-			"SNOW 3G Generated auth tag not as expected");
+			DIGEST_BYTE_LENGTH_KASUMI_F9,
+			"ZUC Generated auth tag not as expected");
 	}
 	return 0;
 }
 
 static int
-test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
+test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
@@ -4783,6 +5231,15 @@  test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 	uint8_t digest_buffer[10000];
 
 	struct rte_cryptodev_info dev_info;
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+
+	/* Check if device supports ZUC EIA3 */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
@@ -4806,15 +5263,15 @@  test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 		}
 	}
 
-	/* Create SNOW 3G session */
+	/* Create ZUC session */
 	retval = create_wireless_algo_auth_cipher_session(
 			ts_params->valid_devs[0],
 			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
 					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
 			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
 					: RTE_CRYPTO_AUTH_OP_GENERATE),
-			RTE_CRYPTO_AUTH_SNOW3G_UIA2,
-			RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
+			RTE_CRYPTO_AUTH_ZUC_EIA3,
+			RTE_CRYPTO_CIPHER_ZUC_EEA3,
 			tdata->key.data, tdata->key.len,
 			tdata->auth_iv.len, tdata->digest.len,
 			tdata->cipher_iv.len);
@@ -4856,18 +5313,18 @@  test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 	}
 	memset(buffer, 0, sizeof(buffer));
 
-	/* Create SNOW 3G operation */
+	/* Create ZUC operation */
 	retval = create_wireless_algo_auth_cipher_operation(
 		tdata->digest.len,
 		tdata->cipher_iv.data, tdata->cipher_iv.len,
-		tdata->auth_iv.data, tdata->auth_iv.len,
+		NULL, 0,
 		(tdata->digest.offset_bytes == 0 ?
 		(verify ? ciphertext_pad_len : plaintext_pad_len)
 			: tdata->digest.offset_bytes),
 		tdata->validCipherLenInBits.len,
-		tdata->cipher.offset_bits,
+		tdata->validCipherOffsetInBits.len,
 		tdata->validAuthLenInBits.len,
-		tdata->auth.offset_bits,
+		0,
 		op_mode, 1);
 
 	if (retval < 0)
@@ -4930,742 +5387,706 @@  test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 			plaintext,
 			tdata->plaintext.data,
 			tdata->plaintext.len >> 3,
-			"SNOW 3G Plaintext data not as expected");
+			"ZUC Plaintext data not as expected");
 	} else {
 		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
 			ciphertext,
 			tdata->ciphertext.data,
 			tdata->validDataLenInBits.len,
-			"SNOW 3G Ciphertext data not as expected");
+			"ZUC Ciphertext data not as expected");
 
 		TEST_ASSERT_BUFFERS_ARE_EQUAL(
 			digest,
 			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
-			"SNOW 3G Generated auth tag not as expected");
+			DIGEST_BYTE_LENGTH_KASUMI_F9,
+			"ZUC Generated auth tag not as expected");
 	}
 	return 0;
 }
 
 static int
-test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
-	uint8_t op_mode, uint8_t verify)
+test_kasumi_encryption_test_case_1(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_kasumi_encryption(&kasumi_test_case_1);
+}
 
-	int retval;
+static int
+test_kasumi_encryption_test_case_1_sgl(void)
+{
+	return test_kasumi_encryption_sgl(&kasumi_test_case_1);
+}
 
-	uint8_t *plaintext = NULL, *ciphertext = NULL;
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	unsigned int ciphertext_pad_len;
-	unsigned int ciphertext_len;
+static int
+test_kasumi_encryption_test_case_1_oop(void)
+{
+	return test_kasumi_encryption_oop(&kasumi_test_case_1);
+}
 
-	struct rte_cryptodev_info dev_info;
+static int
+test_kasumi_encryption_test_case_1_oop_sgl(void)
+{
+	return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
+}
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+static int
+test_kasumi_encryption_test_case_2(void)
+{
+	return test_kasumi_encryption(&kasumi_test_case_2);
+}
 
-	uint64_t feat_flags = dev_info.feature_flags;
+static int
+test_kasumi_encryption_test_case_3(void)
+{
+	return test_kasumi_encryption(&kasumi_test_case_3);
+}
 
-	if (op_mode == OUT_OF_PLACE) {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
-			printf("Device doesn't support digest encrypted.\n");
-			return -ENOTSUP;
-		}
-	}
+static int
+test_kasumi_encryption_test_case_4(void)
+{
+	return test_kasumi_encryption(&kasumi_test_case_4);
+}
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_auth_cipher_session(
-			ts_params->valid_devs[0],
-			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
-					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
-			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
-					: RTE_CRYPTO_AUTH_OP_GENERATE),
-			RTE_CRYPTO_AUTH_KASUMI_F9,
-			RTE_CRYPTO_CIPHER_KASUMI_F8,
-			tdata->key.data, tdata->key.len,
-			0, tdata->digest.len,
-			tdata->cipher_iv.len);
+static int
+test_kasumi_encryption_test_case_5(void)
+{
+	return test_kasumi_encryption(&kasumi_test_case_5);
+}
 
-	if (retval < 0)
-		return retval;
+static int
+test_kasumi_decryption_test_case_1(void)
+{
+	return test_kasumi_decryption(&kasumi_test_case_1);
+}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	if (op_mode == OUT_OF_PLACE)
-		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+static int
+test_kasumi_decryption_test_case_1_oop(void)
+{
+	return test_kasumi_decryption_oop(&kasumi_test_case_1);
+}
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-		rte_pktmbuf_tailroom(ut_params->ibuf));
-	if (op_mode == OUT_OF_PLACE)
-		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->obuf));
+static int
+test_kasumi_decryption_test_case_2(void)
+{
+	return test_kasumi_decryption(&kasumi_test_case_2);
+}
 
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+static int
+test_kasumi_decryption_test_case_3(void)
+{
+	return test_kasumi_decryption(&kasumi_test_case_3);
+}
 
-	if (verify) {
-		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-					ciphertext_pad_len);
-		memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
-		if (op_mode == OUT_OF_PLACE)
-			rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
-	} else {
-		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-					plaintext_pad_len);
-		memcpy(plaintext, tdata->plaintext.data, plaintext_len);
-		if (op_mode == OUT_OF_PLACE)
-			rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
-		debug_hexdump(stdout, "plaintext:", plaintext,
-			plaintext_len);
-	}
+static int
+test_kasumi_decryption_test_case_4(void)
+{
+	return test_kasumi_decryption(&kasumi_test_case_4);
+}
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_auth_cipher_operation(
-		tdata->digest.len,
-		tdata->cipher_iv.data, tdata->cipher_iv.len,
-		NULL, 0,
-		(tdata->digest.offset_bytes == 0 ?
-		(verify ? ciphertext_pad_len : plaintext_pad_len)
-			: tdata->digest.offset_bytes),
-		tdata->validCipherLenInBits.len,
-		tdata->validCipherOffsetInBits.len,
-		tdata->validAuthLenInBits.len,
-		0,
-		op_mode, 0);
+static int
+test_kasumi_decryption_test_case_5(void)
+{
+	return test_kasumi_decryption(&kasumi_test_case_5);
+}
+static int
+test_snow3g_encryption_test_case_1(void)
+{
+	return test_snow3g_encryption(&snow3g_test_case_1);
+}
 
-	if (retval < 0)
-		return retval;
+static int
+test_snow3g_encryption_test_case_1_oop(void)
+{
+	return test_snow3g_encryption_oop(&snow3g_test_case_1);
+}
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+static int
+test_snow3g_encryption_test_case_1_oop_sgl(void)
+{
+	return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
+}
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
-	ut_params->obuf = (op_mode == IN_PLACE ?
-		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
+static int
+test_snow3g_encryption_test_case_1_offset_oop(void)
+{
+	return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
+}
 
+static int
+test_snow3g_encryption_test_case_2(void)
+{
+	return test_snow3g_encryption(&snow3g_test_case_2);
+}
 
-	if (verify) {
-		if (ut_params->obuf)
-			plaintext = rte_pktmbuf_mtod(ut_params->obuf,
-							uint8_t *);
-		else
-			plaintext = ciphertext;
+static int
+test_snow3g_encryption_test_case_3(void)
+{
+	return test_snow3g_encryption(&snow3g_test_case_3);
+}
 
-		debug_hexdump(stdout, "plaintext:", plaintext,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
-		debug_hexdump(stdout, "plaintext expected:",
-			tdata->plaintext.data,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
-	} else {
-		if (ut_params->obuf)
-			ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
-							uint8_t *);
-		else
-			ciphertext = plaintext;
+static int
+test_snow3g_encryption_test_case_4(void)
+{
+	return test_snow3g_encryption(&snow3g_test_case_4);
+}
 
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
-		debug_hexdump(stdout, "ciphertext expected:",
-			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
+static int
+test_snow3g_encryption_test_case_5(void)
+{
+	return test_snow3g_encryption(&snow3g_test_case_5);
+}
 
-		ut_params->digest = rte_pktmbuf_mtod(
-			ut_params->obuf, uint8_t *) +
-			(tdata->digest.offset_bytes == 0 ?
-			plaintext_pad_len : tdata->digest.offset_bytes);
+static int
+test_snow3g_decryption_test_case_1(void)
+{
+	return test_snow3g_decryption(&snow3g_test_case_1);
+}
 
-		debug_hexdump(stdout, "digest:", ut_params->digest,
-			tdata->digest.len);
-		debug_hexdump(stdout, "digest expected:",
-			tdata->digest.data, tdata->digest.len);
-	}
+static int
+test_snow3g_decryption_test_case_1_oop(void)
+{
+	return test_snow3g_decryption_oop(&snow3g_test_case_1);
+}
 
-	/* Validate obuf */
-	if (verify) {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len >> 3,
-			"KASUMI Plaintext data not as expected");
-	} else {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->ciphertext.len >> 3,
-			"KASUMI Ciphertext data not as expected");
+static int
+test_snow3g_decryption_test_case_2(void)
+{
+	return test_snow3g_decryption(&snow3g_test_case_2);
+}
 
-		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ut_params->digest,
-			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_KASUMI_F9,
-			"KASUMI Generated auth tag not as expected");
-	}
-	return 0;
+static int
+test_snow3g_decryption_test_case_3(void)
+{
+	return test_snow3g_decryption(&snow3g_test_case_3);
 }
 
 static int
-test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
-	uint8_t op_mode, uint8_t verify)
+test_snow3g_decryption_test_case_4(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_snow3g_decryption(&snow3g_test_case_4);
+}
 
-	int retval;
+static int
+test_snow3g_decryption_test_case_5(void)
+{
+	return test_snow3g_decryption(&snow3g_test_case_5);
+}
 
-	const uint8_t *plaintext = NULL;
-	const uint8_t *ciphertext = NULL;
-	const uint8_t *digest = NULL;
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	unsigned int ciphertext_pad_len;
-	unsigned int ciphertext_len;
-	uint8_t buffer[10000];
-	uint8_t digest_buffer[10000];
-
-	struct rte_cryptodev_info dev_info;
-
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+/*
+ * Function prepares snow3g_hash_test_data from snow3g_test_data.
+ * Pattern digest from snow3g_test_data must be allocated as
+ * 4 last bytes in plaintext.
+ */
+static void
+snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
+		struct snow3g_hash_test_data *output)
+{
+	if ((pattern != NULL) && (output != NULL)) {
+		output->key.len = pattern->key.len;
 
-	uint64_t feat_flags = dev_info.feature_flags;
+		memcpy(output->key.data,
+		pattern->key.data, pattern->key.len);
 
-	if (op_mode == IN_PLACE) {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
-			printf("Device doesn't support in-place scatter-gather "
-					"in both input and output mbufs.\n");
-			return -ENOTSUP;
-		}
-	} else {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
-			printf("Device doesn't support out-of-place scatter-gather "
-					"in both input and output mbufs.\n");
-			return -ENOTSUP;
-		}
-		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
-			printf("Device doesn't support digest encrypted.\n");
-			return -ENOTSUP;
-		}
-	}
+		output->auth_iv.len = pattern->auth_iv.len;
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_auth_cipher_session(
-			ts_params->valid_devs[0],
-			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
-					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
-			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
-					: RTE_CRYPTO_AUTH_OP_GENERATE),
-			RTE_CRYPTO_AUTH_KASUMI_F9,
-			RTE_CRYPTO_CIPHER_KASUMI_F8,
-			tdata->key.data, tdata->key.len,
-			0, tdata->digest.len,
-			tdata->cipher_iv.len);
+		memcpy(output->auth_iv.data,
+		pattern->auth_iv.data, pattern->auth_iv.len);
 
-	if (retval < 0)
-		return retval;
+		output->plaintext.len = pattern->plaintext.len;
 
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+		memcpy(output->plaintext.data,
+		pattern->plaintext.data, pattern->plaintext.len >> 3);
 
-	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 15, 0);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
+		output->digest.len = pattern->digest.len;
 
-	if (op_mode == OUT_OF_PLACE) {
-		ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
-				plaintext_pad_len, 15, 0);
-		TEST_ASSERT_NOT_NULL(ut_params->obuf,
-				"Failed to allocate output buffer in mempool");
-	}
+		memcpy(output->digest.data,
+		&pattern->plaintext.data[pattern->digest.offset_bytes],
+		pattern->digest.len);
 
-	if (verify) {
-		pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
-			tdata->ciphertext.data);
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					ciphertext_len, buffer);
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
-	} else {
-		pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
-			tdata->plaintext.data);
-		plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					plaintext_len, buffer);
-		debug_hexdump(stdout, "plaintext:", plaintext,
-			plaintext_len);
+		output->validAuthLenInBits.len =
+		pattern->validAuthLenInBits.len;
 	}
-	memset(buffer, 0, sizeof(buffer));
+}
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_auth_cipher_operation(
-		tdata->digest.len,
-		tdata->cipher_iv.data, tdata->cipher_iv.len,
-		NULL, 0,
-		(tdata->digest.offset_bytes == 0 ?
-		(verify ? ciphertext_pad_len : plaintext_pad_len)
-			: tdata->digest.offset_bytes),
-		tdata->validCipherLenInBits.len,
-		tdata->validCipherOffsetInBits.len,
-		tdata->validAuthLenInBits.len,
-		0,
-		op_mode, 1);
+/*
+ * Test case verify computed cipher and digest from snow3g_test_case_7 data.
+ */
+static int
+test_snow3g_decryption_with_digest_test_case_1(void)
+{
+	struct snow3g_hash_test_data snow3g_hash_data;
 
-	if (retval < 0)
-		return retval;
+	/*
+	 * Function prepare data for hash veryfication test case.
+	 * Digest is allocated in 4 last bytes in plaintext, pattern.
+	 */
+	snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+	return test_snow3g_decryption(&snow3g_test_case_7) &
+			test_snow3g_authentication_verify(&snow3g_hash_data);
+}
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+static int
+test_snow3g_cipher_auth_test_case_1(void)
+{
+	return test_snow3g_cipher_auth(&snow3g_test_case_3);
+}
 
-	ut_params->obuf = (op_mode == IN_PLACE ?
-		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
+static int
+test_snow3g_auth_cipher_test_case_1(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
+}
 
-	if (verify) {
-		if (ut_params->obuf)
-			plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
-					plaintext_len, buffer);
-		else
-			plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					plaintext_len, buffer);
+static int
+test_snow3g_auth_cipher_test_case_2(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
+}
 
-		debug_hexdump(stdout, "plaintext:", plaintext,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
-		debug_hexdump(stdout, "plaintext expected:",
-			tdata->plaintext.data,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
-	} else {
-		if (ut_params->obuf)
-			ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
-					ciphertext_len, buffer);
-		else
-			ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					ciphertext_len, buffer);
+static int
+test_snow3g_auth_cipher_test_case_2_oop(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
+}
 
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
-		debug_hexdump(stdout, "ciphertext expected:",
-			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
+static int
+test_snow3g_auth_cipher_part_digest_enc(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			IN_PLACE, 0);
+}
 
-		if (ut_params->obuf)
-			digest = rte_pktmbuf_read(ut_params->obuf,
-				(tdata->digest.offset_bytes == 0 ?
-				plaintext_pad_len : tdata->digest.offset_bytes),
-				tdata->digest.len, digest_buffer);
-		else
-			digest = rte_pktmbuf_read(ut_params->ibuf,
-				(tdata->digest.offset_bytes == 0 ?
-				plaintext_pad_len : tdata->digest.offset_bytes),
-				tdata->digest.len, digest_buffer);
+static int
+test_snow3g_auth_cipher_part_digest_enc_oop(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			OUT_OF_PLACE, 0);
+}
 
-		debug_hexdump(stdout, "digest:", digest,
-			tdata->digest.len);
-		debug_hexdump(stdout, "digest expected:",
-			tdata->digest.data, tdata->digest.len);
-	}
+static int
+test_snow3g_auth_cipher_test_case_3_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
+}
 
-	/* Validate obuf */
-	if (verify) {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len >> 3,
-			"KASUMI Plaintext data not as expected");
-	} else {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->validDataLenInBits.len,
-			"KASUMI Ciphertext data not as expected");
+static int
+test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
+}
 
-		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			digest,
-			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_KASUMI_F9,
-			"KASUMI Generated auth tag not as expected");
-	}
-	return 0;
+static int
+test_snow3g_auth_cipher_part_digest_enc_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			IN_PLACE, 0);
 }
 
 static int
-test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
+test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			OUT_OF_PLACE, 0);
+}
 
-	int retval;
-
-	uint8_t *plaintext, *ciphertext;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
+static int
+test_snow3g_auth_cipher_verify_test_case_1(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
+}
 
-	/* Create KASUMI session */
-	retval = create_wireless_algo_cipher_auth_session(
-			ts_params->valid_devs[0],
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			RTE_CRYPTO_AUTH_KASUMI_F9,
-			RTE_CRYPTO_CIPHER_KASUMI_F8,
-			tdata->key.data, tdata->key.len,
-			0, tdata->digest.len,
-			tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
+static int
+test_snow3g_auth_cipher_verify_test_case_2(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
+}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+static int
+test_snow3g_auth_cipher_verify_test_case_2_oop(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
+}
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+static int
+test_snow3g_auth_cipher_verify_part_digest_enc(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			IN_PLACE, 1);
+}
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+static int
+test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			OUT_OF_PLACE, 1);
+}
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+static int
+test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
+}
 
-	/* Create KASUMI operation */
-	retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
-				tdata->digest.len, NULL, 0,
-				plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
-				tdata->validCipherOffsetInBits.len,
-				tdata->validAuthLenInBits.len,
-				0
-				);
-	if (retval < 0)
-		return retval;
+static int
+test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
+}
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+static int
+test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			IN_PLACE, 1);
+}
 
-	if (ut_params->op->sym->m_dst)
-		ut_params->obuf = ut_params->op->sym->m_dst;
-	else
-		ut_params->obuf = ut_params->op->sym->m_src;
+static int
+test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
+{
+	return test_snow3g_auth_cipher_sgl(
+		&snow3g_auth_cipher_partial_digest_encryption,
+			OUT_OF_PLACE, 1);
+}
 
-	ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
-				tdata->validCipherOffsetInBits.len >> 3);
+static int
+test_snow3g_auth_cipher_with_digest_test_case_1(void)
+{
+	return test_snow3g_auth_cipher(
+		&snow3g_test_case_7, IN_PLACE, 0);
+}
 
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-			+ plaintext_pad_len;
+static int
+test_kasumi_auth_cipher_test_case_1(void)
+{
+	return test_kasumi_auth_cipher(
+		&kasumi_test_case_3, IN_PLACE, 0);
+}
 
-	const uint8_t *reference_ciphertext = tdata->ciphertext.data +
-				(tdata->validCipherOffsetInBits.len >> 3);
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		reference_ciphertext,
-		tdata->validCipherLenInBits.len,
-		"KASUMI Ciphertext data not as expected");
+static int
+test_kasumi_auth_cipher_test_case_2(void)
+{
+	return test_kasumi_auth_cipher(
+		&kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
+}
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-		ut_params->digest,
-		tdata->digest.data,
-		DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
-		"KASUMI Generated auth tag not as expected");
-	return 0;
+static int
+test_kasumi_auth_cipher_test_case_2_oop(void)
+{
+	return test_kasumi_auth_cipher(
+		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
 }
 
 static int
-test_zuc_encryption(const struct wireless_test_data *tdata)
+test_kasumi_auth_cipher_test_case_2_sgl(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_kasumi_auth_cipher_sgl(
+		&kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
+}
 
-	int retval;
-	uint8_t *plaintext, *ciphertext;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
+static int
+test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
+{
+	return test_kasumi_auth_cipher_sgl(
+		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
+}
 
-	struct rte_cryptodev_sym_capability_idx cap_idx;
+static int
+test_kasumi_auth_cipher_verify_test_case_1(void)
+{
+	return test_kasumi_auth_cipher(
+		&kasumi_test_case_3, IN_PLACE, 1);
+}
 
-	/* Check if device supports ZUC EEA3 */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
+static int
+test_kasumi_auth_cipher_verify_test_case_2(void)
+{
+	return test_kasumi_auth_cipher(
+		&kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
+}
 
-	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-			&cap_idx) == NULL)
-		return -ENOTSUP;
+static int
+test_kasumi_auth_cipher_verify_test_case_2_oop(void)
+{
+	return test_kasumi_auth_cipher(
+		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
+}
 
-	/* Create ZUC session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-					RTE_CRYPTO_CIPHER_ZUC_EEA3,
-					tdata->key.data, tdata->key.len,
-					tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
+static int
+test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
+{
+	return test_kasumi_auth_cipher_sgl(
+		&kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
+}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+static int
+test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
+{
+	return test_kasumi_auth_cipher_sgl(
+		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
+}
 
-	/* Clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	       rte_pktmbuf_tailroom(ut_params->ibuf));
+static int
+test_kasumi_cipher_auth_test_case_1(void)
+{
+	return test_kasumi_cipher_auth(&kasumi_test_case_6);
+}
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+static int
+test_zuc_encryption_test_case_1(void)
+{
+	return test_zuc_encryption(&zuc_test_case_cipher_193b);
+}
 
-	debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+static int
+test_zuc_encryption_test_case_2(void)
+{
+	return test_zuc_encryption(&zuc_test_case_cipher_800b);
+}
 
-	/* Create ZUC operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-					tdata->cipher_iv.len,
-					tdata->plaintext.len,
-					0);
-	if (retval < 0)
-		return retval;
+static int
+test_zuc_encryption_test_case_3(void)
+{
+	return test_zuc_encryption(&zuc_test_case_cipher_1570b);
+}
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+static int
+test_zuc_encryption_test_case_4(void)
+{
+	return test_zuc_encryption(&zuc_test_case_cipher_2798b);
+}
 
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
-	else
-		ciphertext = plaintext;
+static int
+test_zuc_encryption_test_case_5(void)
+{
+	return test_zuc_encryption(&zuc_test_case_cipher_4019b);
+}
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+static int
+test_zuc_encryption_test_case_6_sgl(void)
+{
+	return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
+}
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		tdata->ciphertext.data,
-		tdata->validCipherLenInBits.len,
-		"ZUC Ciphertext data not as expected");
-	return 0;
+static int
+test_zuc_hash_generate_test_case_1(void)
+{
+	return test_zuc_authentication(&zuc_test_case_auth_1b);
 }
 
 static int
-test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
+test_zuc_hash_generate_test_case_2(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_zuc_authentication(&zuc_test_case_auth_90b);
+}
 
-	int retval;
+static int
+test_zuc_hash_generate_test_case_3(void)
+{
+	return test_zuc_authentication(&zuc_test_case_auth_577b);
+}
 
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	const uint8_t *ciphertext;
-	uint8_t ciphertext_buffer[2048];
-	struct rte_cryptodev_info dev_info;
+static int
+test_zuc_hash_generate_test_case_4(void)
+{
+	return test_zuc_authentication(&zuc_test_case_auth_2079b);
+}
 
-	struct rte_cryptodev_sym_capability_idx cap_idx;
+static int
+test_zuc_hash_generate_test_case_5(void)
+{
+	return test_zuc_authentication(&zuc_test_auth_5670b);
+}
 
-	/* Check if device supports ZUC EEA3 */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
+static int
+test_zuc_hash_generate_test_case_6(void)
+{
+	return test_zuc_authentication(&zuc_test_case_auth_128b);
+}
 
-	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-			&cap_idx) == NULL)
+static int
+test_zuc_hash_generate_test_case_7(void)
+{
+	/* This test is not for SW ZUC PMD */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_ZUC_PMD)))
 		return -ENOTSUP;
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	return test_zuc_authentication(&zuc_test_case_auth_2080b);
+}
 
-	uint64_t feat_flags = dev_info.feature_flags;
+static int
+test_zuc_hash_generate_test_case_8(void)
+{
+	return test_zuc_authentication(&zuc_test_case_auth_584b);
+}
 
-	if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
-		printf("Device doesn't support in-place scatter-gather. "
-				"Test Skipped.\n");
+static int
+test_zuc_cipher_auth_test_case_1(void)
+{
+	return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
+}
+
+static int
+test_zuc_cipher_auth_test_case_2(void)
+{
+	return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
+}
+
+static int
+test_zuc_auth_cipher_test_case_1(void)
+{
+	/* This test is not for SW ZUC PMD */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_ZUC_PMD)))
 		return -ENOTSUP;
-	}
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	return test_zuc_auth_cipher(
+		&zuc_auth_cipher_test_case_1, IN_PLACE, 0);
+}
 
-	/* Append data which is padded to a multiple */
-	/* of the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
+static int
+test_zuc_auth_cipher_test_case_1_oop(void)
+{
+	return test_zuc_auth_cipher(
+		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
+}
 
-	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 10, 0);
+static int
+test_zuc_auth_cipher_test_case_1_sgl(void)
+{
+	return test_zuc_auth_cipher_sgl(
+		&zuc_auth_cipher_test_case_1, IN_PLACE, 0);
+}
 
-	pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
-			tdata->plaintext.data);
+static int
+test_zuc_auth_cipher_test_case_1_oop_sgl(void)
+{
+	return test_zuc_auth_cipher_sgl(
+		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
+}
 
-	/* Create ZUC session */
-	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_CIPHER_ZUC_EEA3,
-			tdata->key.data, tdata->key.len,
-			tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
+static int
+test_zuc_auth_cipher_verify_test_case_1(void)
+{
+	return test_zuc_auth_cipher(
+		&zuc_auth_cipher_test_case_1, IN_PLACE, 1);
+}
 
-	/* Clear mbuf payload */
+static int
+test_zuc_auth_cipher_verify_test_case_1_oop(void)
+{
+	return test_zuc_auth_cipher(
+		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
+}
 
-	pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
+static int
+test_zuc_auth_cipher_verify_test_case_1_sgl(void)
+{
+	return test_zuc_auth_cipher_sgl(
+		&zuc_auth_cipher_test_case_1, IN_PLACE, 1);
+}
 
-	/* Create ZUC operation */
-	retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-			tdata->cipher_iv.len, tdata->plaintext.len,
-			0);
-	if (retval < 0)
-		return retval;
+static int
+test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
+{
+	return test_zuc_auth_cipher_sgl(
+		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
+}
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+static int
+test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
+{
+	uint8_t dev_id = testsuite_params.valid_devs[0];
 
-	ut_params->obuf = ut_params->op->sym->m_dst;
-	if (ut_params->obuf)
-		ciphertext = rte_pktmbuf_read(ut_params->obuf,
-			0, plaintext_len, ciphertext_buffer);
-	else
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf,
-			0, plaintext_len, ciphertext_buffer);
+	struct rte_cryptodev_sym_capability_idx cap_idx;
 
-	/* Validate obuf */
-	debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
+	/* Check if device supports particular cipher algorithm */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = tdata->cipher_algo;
+	if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-		ciphertext,
-		tdata->ciphertext.data,
-		tdata->validCipherLenInBits.len,
-		"ZUC Ciphertext data not as expected");
+	/* Check if device supports particular hash algorithm */
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = tdata->auth_algo;
+	if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
+		return -ENOTSUP;
 
 	return 0;
 }
 
 static int
-test_zuc_authentication(const struct wireless_test_data *tdata)
+test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
+	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
 	int retval;
-	unsigned plaintext_pad_len;
-	unsigned plaintext_len;
-	uint8_t *plaintext;
 
-	struct rte_cryptodev_sym_capability_idx cap_idx;
+	uint8_t *plaintext = NULL, *ciphertext = NULL;
+	unsigned int plaintext_pad_len;
+	unsigned int plaintext_len;
+	unsigned int ciphertext_pad_len;
+	unsigned int ciphertext_len;
 
-	/* Check if device supports ZUC EIA3 */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+	struct rte_cryptodev_info dev_info;
+	struct rte_crypto_op *op;
 
-	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-			&cap_idx) == NULL)
+	/* Check if device supports particular algorithms separately */
+	if (test_mixed_check_if_unsupported(tdata))
 		return -ENOTSUP;
 
-	/* Create ZUC session */
-	retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
-			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			RTE_CRYPTO_AUTH_ZUC_EIA3);
-	if (retval < 0)
-		return retval;
-
-	/* alloc mbuf and set payload */
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-	rte_pktmbuf_tailroom(ut_params->ibuf));
+	uint64_t feat_flags = dev_info.feature_flags;
 
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	/* Append data which is padded to a multiple of */
-	/* the algorithms block size */
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
-
-	/* Create ZUC operation */
-	retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
-			tdata->auth_iv.data, tdata->auth_iv.len,
-			plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-			tdata->validAuthLenInBits.len,
-			0);
-	if (retval < 0)
-		return retval;
-
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-				ut_params->op);
-	ut_params->obuf = ut_params->op->sym->m_src;
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-	ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-			+ plaintext_pad_len;
-
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-	ut_params->digest,
-	tdata->digest.data,
-	DIGEST_BYTE_LENGTH_KASUMI_F9,
-	"ZUC Generated auth tag not as expected");
-
-	return 0;
-}
-
-static int
-test_zuc_auth_cipher(const struct wireless_test_data *tdata,
-	uint8_t op_mode, uint8_t verify)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-
-	int retval;
-
-	uint8_t *plaintext = NULL, *ciphertext = NULL;
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	unsigned int ciphertext_pad_len;
-	unsigned int ciphertext_len;
-
-	struct rte_cryptodev_info dev_info;
-	struct rte_cryptodev_sym_capability_idx cap_idx;
-
-	/* Check if device supports ZUC EIA3 */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
-
-	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-			&cap_idx) == NULL)
-		return -ENOTSUP;
-
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
-
-	uint64_t feat_flags = dev_info.feature_flags;
-
-	if (op_mode == OUT_OF_PLACE) {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
-			printf("Device doesn't support digest encrypted.\n");
-			return -ENOTSUP;
-		}
-	}
-
-	/* Create ZUC session */
-	retval = create_wireless_algo_auth_cipher_session(
-			ts_params->valid_devs[0],
-			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
-					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
-			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
-					: RTE_CRYPTO_AUTH_OP_GENERATE),
-			RTE_CRYPTO_AUTH_ZUC_EIA3,
-			RTE_CRYPTO_CIPHER_ZUC_EEA3,
-			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
-			tdata->cipher_iv.len);
+	if (op_mode == OUT_OF_PLACE) {
+		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+			printf("Device doesn't support digest encrypted.\n");
+			return -ENOTSUP;
+		}
+	}
 
+	/* Create the session */
+	if (verify)
+		retval = create_wireless_algo_cipher_auth_session(
+				ts_params->valid_devs[0],
+				RTE_CRYPTO_CIPHER_OP_DECRYPT,
+				RTE_CRYPTO_AUTH_OP_VERIFY,
+				tdata->auth_algo,
+				tdata->cipher_algo,
+				tdata->auth_key.data, tdata->auth_key.len,
+				tdata->auth_iv.len, tdata->digest_enc.len,
+				tdata->cipher_iv.len);
+	else
+		retval = create_wireless_algo_auth_cipher_session(
+				ts_params->valid_devs[0],
+				RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+				RTE_CRYPTO_AUTH_OP_GENERATE,
+				tdata->auth_algo,
+				tdata->cipher_algo,
+				tdata->auth_key.data, tdata->auth_key.len,
+				tdata->auth_iv.len, tdata->digest_enc.len,
+				tdata->cipher_iv.len);
 	if (retval < 0)
 		return retval;
 
@@ -5678,117 +6099,142 @@  test_zuc_auth_cipher(const struct wireless_test_data *tdata,
 		rte_pktmbuf_tailroom(ut_params->ibuf));
 	if (op_mode == OUT_OF_PLACE)
 		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->obuf));
+				rte_pktmbuf_tailroom(ut_params->obuf));
 
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
 	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
 	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
 
 	if (verify) {
 		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-					ciphertext_pad_len);
+				ciphertext_pad_len);
 		memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 		if (op_mode == OUT_OF_PLACE)
 			rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
 		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
+				ciphertext_len);
 	} else {
 		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-					plaintext_pad_len);
+				plaintext_pad_len);
 		memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 		if (op_mode == OUT_OF_PLACE)
 			rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
-		debug_hexdump(stdout, "plaintext:", plaintext,
-			plaintext_len);
+		debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 	}
 
-	/* Create ZUC operation */
-	retval = create_wireless_algo_auth_cipher_operation(
-		tdata->digest.len,
-		tdata->cipher_iv.data, tdata->cipher_iv.len,
-		tdata->auth_iv.data, tdata->auth_iv.len,
-		(tdata->digest.offset_bytes == 0 ?
-		(verify ? ciphertext_pad_len : plaintext_pad_len)
-			: tdata->digest.offset_bytes),
-		tdata->validCipherLenInBits.len,
-		tdata->validCipherOffsetInBits.len,
-		tdata->validAuthLenInBits.len,
-		0,
-		op_mode, 0);
-
+	/* Create the operation */
+	if (verify)
+		retval = create_wireless_algo_cipher_hash_operation(
+				tdata->digest_enc.data, tdata->digest_enc.len,
+				tdata->auth_iv.data, tdata->auth_iv.len,
+				plaintext_len, RTE_CRYPTO_AUTH_OP_VERIFY,
+				tdata->cipher_iv.data, tdata->cipher_iv.len,
+				tdata->validCipherLen.len_bits,
+				tdata->cipher.offset_bits,
+				tdata->validAuthLen.len_bits,
+				tdata->auth.offset_bits);
+	else
+		retval = create_wireless_algo_auth_cipher_operation(
+				tdata->digest_enc.len,
+				tdata->cipher_iv.data, tdata->cipher_iv.len,
+				tdata->auth_iv.data, tdata->auth_iv.len,
+				(tdata->digest_enc.offset == 0 ?
+					plaintext_pad_len
+					: tdata->digest_enc.offset),
+				tdata->validCipherLen.len_bits,
+				tdata->cipher.offset_bits,
+				tdata->validAuthLen.len_bits,
+				tdata->auth.offset_bits,
+				op_mode, 0);
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
+	/* Check if the op failed because the device doesn't */
+	/* support this particular combination of algorithms */
+	if (op == NULL && ut_params->op->status ==
+			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
+		printf("Device doesn't support this mixed combination. "
+				"Test Skipped.\n");
+		return -ENOTSUP;
+	}
+
+	ut_params->op = op;
+
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
 	ut_params->obuf = (op_mode == IN_PLACE ?
-		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
-
+			ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
 	if (verify) {
 		if (ut_params->obuf)
 			plaintext = rte_pktmbuf_mtod(ut_params->obuf,
 							uint8_t *);
 		else
-			plaintext = ciphertext;
+			plaintext = ciphertext +
+					(tdata->cipher.offset_bits >> 3);
 
 		debug_hexdump(stdout, "plaintext:", plaintext,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
+				tdata->plaintext.len_bits >> 3);
 		debug_hexdump(stdout, "plaintext expected:",
-			tdata->plaintext.data,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
+				tdata->plaintext.data,
+				tdata->plaintext.len_bits >> 3);
 	} else {
 		if (ut_params->obuf)
 			ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
-							uint8_t *);
+					uint8_t *);
 		else
 			ciphertext = plaintext;
 
 		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
+				ciphertext_len);
 		debug_hexdump(stdout, "ciphertext expected:",
-			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
+				tdata->ciphertext.data,
+				tdata->ciphertext.len_bits >> 3);
 
-		ut_params->digest = rte_pktmbuf_mtod(
-			ut_params->obuf, uint8_t *) +
-			(tdata->digest.offset_bytes == 0 ?
-			plaintext_pad_len : tdata->digest.offset_bytes);
+		ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+				+ (tdata->digest_enc.offset == 0 ?
+		plaintext_pad_len : tdata->digest_enc.offset);
 
 		debug_hexdump(stdout, "digest:", ut_params->digest,
-			tdata->digest.len);
+				tdata->digest_enc.len);
 		debug_hexdump(stdout, "digest expected:",
-			tdata->digest.data, tdata->digest.len);
+				tdata->digest_enc.data,
+				tdata->digest_enc.len);
 	}
 
 	/* Validate obuf */
 	if (verify) {
 		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len >> 3,
-			"ZUC Plaintext data not as expected");
+				plaintext,
+				tdata->plaintext.data,
+				tdata->plaintext.len_bits >> 3,
+				"Plaintext data not as expected");
 	} else {
 		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->ciphertext.len >> 3,
-			"ZUC Ciphertext data not as expected");
+				ciphertext,
+				tdata->ciphertext.data,
+				tdata->validDataLen.len_bits,
+				"Ciphertext data not as expected");
 
 		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ut_params->digest,
-			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_KASUMI_F9,
-			"ZUC Generated auth tag not as expected");
+				ut_params->digest,
+				tdata->digest_enc.data,
+				DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
+				"Generated auth tag not as expected");
 	}
+
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
+
 	return 0;
 }
 
 static int
-test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
+test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
 	uint8_t op_mode, uint8_t verify)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
@@ -5807,14 +6253,10 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 	uint8_t digest_buffer[10000];
 
 	struct rte_cryptodev_info dev_info;
-	struct rte_cryptodev_sym_capability_idx cap_idx;
-
-	/* Check if device supports ZUC EIA3 */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
+	struct rte_crypto_op *op;
 
-	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
-			&cap_idx) == NULL)
+	/* Check if device supports particular algorithms */
+	if (test_mixed_check_if_unsupported(tdata))
 		return -ENOTSUP;
 
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
@@ -5839,35 +6281,43 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 		}
 	}
 
-	/* Create ZUC session */
-	retval = create_wireless_algo_auth_cipher_session(
-			ts_params->valid_devs[0],
-			(verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
-					: RTE_CRYPTO_CIPHER_OP_ENCRYPT),
-			(verify ? RTE_CRYPTO_AUTH_OP_VERIFY
-					: RTE_CRYPTO_AUTH_OP_GENERATE),
-			RTE_CRYPTO_AUTH_ZUC_EIA3,
-			RTE_CRYPTO_CIPHER_ZUC_EEA3,
-			tdata->key.data, tdata->key.len,
-			tdata->auth_iv.len, tdata->digest.len,
-			tdata->cipher_iv.len);
-
-	if (retval < 0)
-		return retval;
-
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
-	plaintext_len = ceil_byte_length(tdata->plaintext.len);
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
-
-	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			plaintext_pad_len, 15, 0);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
-
-	if (op_mode == OUT_OF_PLACE) {
-		ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
-				plaintext_pad_len, 15, 0);
+	/* Create the session */
+	if (verify)
+		retval = create_wireless_algo_cipher_auth_session(
+				ts_params->valid_devs[0],
+				RTE_CRYPTO_CIPHER_OP_DECRYPT,
+				RTE_CRYPTO_AUTH_OP_VERIFY,
+				tdata->auth_algo,
+				tdata->cipher_algo,
+				tdata->auth_key.data, tdata->auth_key.len,
+				tdata->auth_iv.len, tdata->digest_enc.len,
+				tdata->cipher_iv.len);
+	else
+		retval = create_wireless_algo_auth_cipher_session(
+				ts_params->valid_devs[0],
+				RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+				RTE_CRYPTO_AUTH_OP_GENERATE,
+				tdata->auth_algo,
+				tdata->cipher_algo,
+				tdata->auth_key.data, tdata->auth_key.len,
+				tdata->auth_iv.len, tdata->digest_enc.len,
+				tdata->cipher_iv.len);
+	if (retval < 0)
+		return retval;
+
+	ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
+	plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
+	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
+	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+
+	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
+			ciphertext_pad_len, 15, 0);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
+
+	if (op_mode == OUT_OF_PLACE) {
+		ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
+				plaintext_pad_len, 15, 0);
 		TEST_ASSERT_NOT_NULL(ut_params->obuf,
 				"Failed to allocate output buffer in mempool");
 	}
@@ -5889,30 +6339,51 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 	}
 	memset(buffer, 0, sizeof(buffer));
 
-	/* Create ZUC operation */
-	retval = create_wireless_algo_auth_cipher_operation(
-		tdata->digest.len,
-		tdata->cipher_iv.data, tdata->cipher_iv.len,
-		NULL, 0,
-		(tdata->digest.offset_bytes == 0 ?
-		(verify ? ciphertext_pad_len : plaintext_pad_len)
-			: tdata->digest.offset_bytes),
-		tdata->validCipherLenInBits.len,
-		tdata->validCipherOffsetInBits.len,
-		tdata->validAuthLenInBits.len,
-		0,
-		op_mode, 1);
-
+	/* Create the operation */
+	if (verify)
+		retval = create_wireless_algo_cipher_hash_operation(
+				tdata->digest_enc.data, tdata->digest_enc.len,
+				tdata->auth_iv.data, tdata->auth_iv.len,
+				plaintext_len, RTE_CRYPTO_AUTH_OP_VERIFY,
+				tdata->cipher_iv.data, tdata->cipher_iv.len,
+				tdata->validCipherLen.len_bits,
+				tdata->cipher.offset_bits,
+				tdata->validAuthLen.len_bits,
+				tdata->auth.offset_bits);
+	else
+		retval = create_wireless_algo_auth_cipher_operation(
+				tdata->digest_enc.len,
+				tdata->cipher_iv.data, tdata->cipher_iv.len,
+				tdata->auth_iv.data, tdata->auth_iv.len,
+				(tdata->digest_enc.offset == 0 ?
+					plaintext_pad_len
+					: tdata->digest_enc.offset),
+				tdata->validCipherLen.len_bits,
+				tdata->cipher.offset_bits,
+				tdata->validAuthLen.len_bits,
+				tdata->auth.offset_bits,
+				op_mode, 1);
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
+	/* Check if the op failed because the device doesn't */
+	/* support this particular combination of algorithms */
+	if (op == NULL && ut_params->op->status ==
+			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
+		printf("Device doesn't support this mixed combination. "
+				"Test Skipped.\n");
+		return -ENOTSUP;
+	}
+
+	ut_params->op = op;
+
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
 	ut_params->obuf = (op_mode == IN_PLACE ?
-		ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
+			ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
 
 	if (verify) {
 		if (ut_params->obuf)
@@ -5923,10 +6394,12 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 					plaintext_len, buffer);
 
 		debug_hexdump(stdout, "plaintext:", plaintext,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
+				(tdata->plaintext.len_bits >> 3) -
+				tdata->digest_enc.len);
 		debug_hexdump(stdout, "plaintext expected:",
-			tdata->plaintext.data,
-			(tdata->plaintext.len >> 3) - tdata->digest.len);
+				tdata->plaintext.data,
+				(tdata->plaintext.len_bits >> 3) -
+				tdata->digest_enc.len);
 	} else {
 		if (ut_params->obuf)
 			ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
@@ -5938,1910 +6411,1808 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 		debug_hexdump(stdout, "ciphertext:", ciphertext,
 			ciphertext_len);
 		debug_hexdump(stdout, "ciphertext expected:",
-			tdata->ciphertext.data, tdata->ciphertext.len >> 3);
+			tdata->ciphertext.data,
+			tdata->ciphertext.len_bits >> 3);
 
 		if (ut_params->obuf)
 			digest = rte_pktmbuf_read(ut_params->obuf,
-				(tdata->digest.offset_bytes == 0 ?
-				plaintext_pad_len : tdata->digest.offset_bytes),
-				tdata->digest.len, digest_buffer);
+					(tdata->digest_enc.offset == 0 ?
+						plaintext_pad_len :
+						tdata->digest_enc.offset),
+					tdata->digest_enc.len, digest_buffer);
 		else
 			digest = rte_pktmbuf_read(ut_params->ibuf,
-				(tdata->digest.offset_bytes == 0 ?
-				plaintext_pad_len : tdata->digest.offset_bytes),
-				tdata->digest.len, digest_buffer);
+					(tdata->digest_enc.offset == 0 ?
+						plaintext_pad_len :
+						tdata->digest_enc.offset),
+					tdata->digest_enc.len, digest_buffer);
 
 		debug_hexdump(stdout, "digest:", digest,
-			tdata->digest.len);
+				tdata->digest_enc.len);
 		debug_hexdump(stdout, "digest expected:",
-			tdata->digest.data, tdata->digest.len);
+				tdata->digest_enc.data, tdata->digest_enc.len);
 	}
 
 	/* Validate obuf */
 	if (verify) {
 		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len >> 3,
-			"ZUC Plaintext data not as expected");
+				plaintext,
+				tdata->plaintext.data,
+				tdata->plaintext.len_bits >> 3,
+				"Plaintext data not as expected");
 	} else {
 		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->validDataLenInBits.len,
-			"ZUC Ciphertext data not as expected");
-
+				ciphertext,
+				tdata->ciphertext.data,
+				tdata->validDataLen.len_bits,
+				"Ciphertext data not as expected");
 		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			digest,
-			tdata->digest.data,
-			DIGEST_BYTE_LENGTH_KASUMI_F9,
-			"ZUC Generated auth tag not as expected");
+				digest,
+				tdata->digest_enc.data,
+				tdata->digest_enc.len,
+				"Generated auth tag not as expected");
 	}
+
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
+
 	return 0;
 }
 
+/** AUTH AES CMAC + CIPHER AES CTR */
+
 static int
-test_kasumi_encryption_test_case_1(void)
+test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
 {
-	return test_kasumi_encryption(&kasumi_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
 }
 
 static int
-test_kasumi_encryption_test_case_1_sgl(void)
+test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
 {
-	return test_kasumi_encryption_sgl(&kasumi_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_kasumi_encryption_test_case_1_oop(void)
+test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
 {
-	return test_kasumi_encryption_oop(&kasumi_test_case_1);
+	return test_mixed_auth_cipher_sgl(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
 }
 
 static int
-test_kasumi_encryption_test_case_1_oop_sgl(void)
+test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
 {
-	return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
+	return test_mixed_auth_cipher_sgl(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_kasumi_encryption_test_case_2(void)
+test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
 {
-	return test_kasumi_encryption(&kasumi_test_case_2);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
 }
 
 static int
-test_kasumi_encryption_test_case_3(void)
+test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
 {
-	return test_kasumi_encryption(&kasumi_test_case_3);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_kasumi_encryption_test_case_4(void)
+test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
 {
-	return test_kasumi_encryption(&kasumi_test_case_4);
+	return test_mixed_auth_cipher_sgl(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
 }
 
 static int
-test_kasumi_encryption_test_case_5(void)
+test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
 {
-	return test_kasumi_encryption(&kasumi_test_case_5);
+	return test_mixed_auth_cipher_sgl(
+		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
 }
 
+/** MIXED AUTH + CIPHER */
+
 static int
-test_kasumi_decryption_test_case_1(void)
+test_auth_zuc_cipher_snow_test_case_1(void)
 {
-	return test_kasumi_decryption(&kasumi_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_kasumi_decryption_test_case_1_oop(void)
+test_verify_auth_zuc_cipher_snow_test_case_1(void)
 {
-	return test_kasumi_decryption_oop(&kasumi_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_kasumi_decryption_test_case_2(void)
+test_auth_aes_cmac_cipher_snow_test_case_1(void)
 {
-	return test_kasumi_decryption(&kasumi_test_case_2);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_kasumi_decryption_test_case_3(void)
+test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
 {
-	return test_kasumi_decryption(&kasumi_test_case_3);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_kasumi_decryption_test_case_4(void)
+test_auth_zuc_cipher_aes_ctr_test_case_1(void)
 {
-	return test_kasumi_decryption(&kasumi_test_case_4);
+	return test_mixed_auth_cipher(
+		&auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_kasumi_decryption_test_case_5(void)
+test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
 {
-	return test_kasumi_decryption(&kasumi_test_case_5);
+	return test_mixed_auth_cipher(
+		&auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
 }
+
 static int
-test_snow3g_encryption_test_case_1(void)
+test_auth_snow_cipher_aes_ctr_test_case_1(void)
 {
-	return test_snow3g_encryption(&snow3g_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_encryption_test_case_1_oop(void)
+test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
 {
-	return test_snow3g_encryption_oop(&snow3g_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_encryption_test_case_1_oop_sgl(void)
+test_auth_snow_cipher_zuc_test_case_1(void)
 {
-	return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
 }
 
-
 static int
-test_snow3g_encryption_test_case_1_offset_oop(void)
+test_verify_auth_snow_cipher_zuc_test_case_1(void)
 {
-	return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_encryption_test_case_2(void)
+test_auth_aes_cmac_cipher_zuc_test_case_1(void)
 {
-	return test_snow3g_encryption(&snow3g_test_case_2);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_encryption_test_case_3(void)
+test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
 {
-	return test_snow3g_encryption(&snow3g_test_case_3);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_encryption_test_case_4(void)
+test_auth_null_cipher_snow_test_case_1(void)
 {
-	return test_snow3g_encryption(&snow3g_test_case_4);
+	return test_mixed_auth_cipher(
+		&auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_encryption_test_case_5(void)
+test_verify_auth_null_cipher_snow_test_case_1(void)
 {
-	return test_snow3g_encryption(&snow3g_test_case_5);
+	return test_mixed_auth_cipher(
+		&auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_decryption_test_case_1(void)
+test_auth_null_cipher_zuc_test_case_1(void)
 {
-	return test_snow3g_decryption(&snow3g_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_decryption_test_case_1_oop(void)
+test_verify_auth_null_cipher_zuc_test_case_1(void)
 {
-	return test_snow3g_decryption_oop(&snow3g_test_case_1);
+	return test_mixed_auth_cipher(
+		&auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_decryption_test_case_2(void)
+test_auth_snow_cipher_null_test_case_1(void)
 {
-	return test_snow3g_decryption(&snow3g_test_case_2);
+	return test_mixed_auth_cipher(
+		&auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_decryption_test_case_3(void)
+test_verify_auth_snow_cipher_null_test_case_1(void)
 {
-	return test_snow3g_decryption(&snow3g_test_case_3);
+	return test_mixed_auth_cipher(
+		&auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_decryption_test_case_4(void)
+test_auth_zuc_cipher_null_test_case_1(void)
 {
-	return test_snow3g_decryption(&snow3g_test_case_4);
+	return test_mixed_auth_cipher(
+		&auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_decryption_test_case_5(void)
-{
-	return test_snow3g_decryption(&snow3g_test_case_5);
-}
-
-/*
- * Function prepares snow3g_hash_test_data from snow3g_test_data.
- * Pattern digest from snow3g_test_data must be allocated as
- * 4 last bytes in plaintext.
- */
-static void
-snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
-		struct snow3g_hash_test_data *output)
+test_verify_auth_zuc_cipher_null_test_case_1(void)
 {
-	if ((pattern != NULL) && (output != NULL)) {
-		output->key.len = pattern->key.len;
-
-		memcpy(output->key.data,
-		pattern->key.data, pattern->key.len);
-
-		output->auth_iv.len = pattern->auth_iv.len;
-
-		memcpy(output->auth_iv.data,
-		pattern->auth_iv.data, pattern->auth_iv.len);
-
-		output->plaintext.len = pattern->plaintext.len;
-
-		memcpy(output->plaintext.data,
-		pattern->plaintext.data, pattern->plaintext.len >> 3);
-
-		output->digest.len = pattern->digest.len;
-
-		memcpy(output->digest.data,
-		&pattern->plaintext.data[pattern->digest.offset_bytes],
-		pattern->digest.len);
-
-		output->validAuthLenInBits.len =
-		pattern->validAuthLenInBits.len;
-	}
+	return test_mixed_auth_cipher(
+		&auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
 }
 
-/*
- * Test case verify computed cipher and digest from snow3g_test_case_7 data.
- */
 static int
-test_snow3g_decryption_with_digest_test_case_1(void)
+test_auth_null_cipher_aes_ctr_test_case_1(void)
 {
-	struct snow3g_hash_test_data snow3g_hash_data;
-
-	/*
-	 * Function prepare data for hash veryfication test case.
-	 * Digest is allocated in 4 last bytes in plaintext, pattern.
-	 */
-	snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
-
-	return test_snow3g_decryption(&snow3g_test_case_7) &
-			test_snow3g_authentication_verify(&snow3g_hash_data);
+	return test_mixed_auth_cipher(
+		&auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_cipher_auth_test_case_1(void)
+test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
 {
-	return test_snow3g_cipher_auth(&snow3g_test_case_3);
+	return test_mixed_auth_cipher(
+		&auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
 }
 
 static int
-test_snow3g_auth_cipher_test_case_1(void)
+test_auth_aes_cmac_cipher_null_test_case_1(void)
 {
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
 }
 
 static int
-test_snow3g_auth_cipher_test_case_2(void)
+test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
 {
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
+	return test_mixed_auth_cipher(
+		&auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
 }
 
-static int
-test_snow3g_auth_cipher_test_case_2_oop(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
-}
+/* ***** AEAD algorithm Tests ***** */
 
 static int
-test_snow3g_auth_cipher_part_digest_enc(void)
+create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
+		enum rte_crypto_aead_operation op,
+		const uint8_t *key, const uint8_t key_len,
+		const uint16_t aad_len, const uint8_t auth_len,
+		uint8_t iv_len)
 {
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			IN_PLACE, 0);
-}
+	uint8_t aead_key[key_len];
 
-static int
-test_snow3g_auth_cipher_part_digest_enc_oop(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			OUT_OF_PLACE, 0);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-static int
-test_snow3g_auth_cipher_test_case_3_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
-}
+	memcpy(aead_key, key, key_len);
 
-static int
-test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
-}
+	/* Setup AEAD Parameters */
+	ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	ut_params->aead_xform.next = NULL;
+	ut_params->aead_xform.aead.algo = algo;
+	ut_params->aead_xform.aead.op = op;
+	ut_params->aead_xform.aead.key.data = aead_key;
+	ut_params->aead_xform.aead.key.length = key_len;
+	ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
+	ut_params->aead_xform.aead.iv.length = iv_len;
+	ut_params->aead_xform.aead.digest_length = auth_len;
+	ut_params->aead_xform.aead.aad_length = aad_len;
 
-static int
-test_snow3g_auth_cipher_part_digest_enc_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			IN_PLACE, 0);
-}
+	debug_hexdump(stdout, "key:", key, key_len);
 
-static int
-test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			OUT_OF_PLACE, 0);
-}
+	/* Create Crypto session*/
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-static int
-test_snow3g_auth_cipher_verify_test_case_1(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
-}
+	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->aead_xform,
+			ts_params->session_priv_mpool);
 
-static int
-test_snow3g_auth_cipher_verify_test_case_2(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
-}
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-static int
-test_snow3g_auth_cipher_verify_test_case_2_oop(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
+	return 0;
 }
 
 static int
-test_snow3g_auth_cipher_verify_part_digest_enc(void)
+create_aead_xform(struct rte_crypto_op *op,
+		enum rte_crypto_aead_algorithm algo,
+		enum rte_crypto_aead_operation aead_op,
+		uint8_t *key, const uint8_t key_len,
+		const uint8_t aad_len, const uint8_t auth_len,
+		uint8_t iv_len)
 {
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			IN_PLACE, 1);
-}
+	TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
+			"failed to allocate space for crypto transform");
 
-static int
-test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			OUT_OF_PLACE, 1);
-}
+	struct rte_crypto_sym_op *sym_op = op->sym;
 
-static int
-test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
-}
+	/* Setup AEAD Parameters */
+	sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	sym_op->xform->next = NULL;
+	sym_op->xform->aead.algo = algo;
+	sym_op->xform->aead.op = aead_op;
+	sym_op->xform->aead.key.data = key;
+	sym_op->xform->aead.key.length = key_len;
+	sym_op->xform->aead.iv.offset = IV_OFFSET;
+	sym_op->xform->aead.iv.length = iv_len;
+	sym_op->xform->aead.digest_length = auth_len;
+	sym_op->xform->aead.aad_length = aad_len;
 
-static int
-test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
-}
+	debug_hexdump(stdout, "key:", key, key_len);
 
-static int
-test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
-{
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			IN_PLACE, 1);
+	return 0;
 }
 
 static int
-test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
+create_aead_operation(enum rte_crypto_aead_operation op,
+		const struct aead_test_data *tdata)
 {
-	return test_snow3g_auth_cipher_sgl(
-		&snow3g_auth_cipher_partial_digest_encryption,
-			OUT_OF_PLACE, 1);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-static int
-test_snow3g_auth_cipher_with_digest_test_case_1(void)
-{
-	return test_snow3g_auth_cipher(
-		&snow3g_test_case_7, IN_PLACE, 0);
-}
+	uint8_t *plaintext, *ciphertext;
+	unsigned int aad_pad_len, plaintext_pad_len;
 
-static int
-test_kasumi_auth_cipher_test_case_1(void)
-{
-	return test_kasumi_auth_cipher(
-		&kasumi_test_case_3, IN_PLACE, 0);
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
-static int
-test_kasumi_auth_cipher_test_case_2(void)
-{
-	return test_kasumi_auth_cipher(
-		&kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
-}
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-static int
-test_kasumi_auth_cipher_test_case_2_oop(void)
-{
-	return test_kasumi_auth_cipher(
-		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
-}
+	/* Append aad data */
+	if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
+		aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
+		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(
+				ut_params->ibuf, aad_pad_len);
+		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+				"no room to append aad");
 
-static int
-test_kasumi_auth_cipher_test_case_2_sgl(void)
-{
-	return test_kasumi_auth_cipher_sgl(
-		&kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
-}
+		sym_op->aead.aad.phys_addr =
+				rte_pktmbuf_iova(ut_params->ibuf);
+		/* Copy AAD 18 bytes after the AAD ptr, according to the API */
+		memcpy(sym_op->aead.aad.data + 18, tdata->aad.data,
+			tdata->aad.len);
+		debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
+			tdata->aad.len);
 
-static int
-test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
-{
-	return test_kasumi_auth_cipher_sgl(
-		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
-}
+		/* Append IV at the end of the crypto operation*/
+		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+				uint8_t *, IV_OFFSET);
 
-static int
-test_kasumi_auth_cipher_verify_test_case_1(void)
-{
-	return test_kasumi_auth_cipher(
-		&kasumi_test_case_3, IN_PLACE, 1);
-}
+		/* Copy IV 1 byte after the IV pointer, according to the API */
+		rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
+		debug_hexdump(stdout, "iv:", iv_ptr,
+			tdata->iv.len);
+	} else {
+		aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
+		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(
+				ut_params->ibuf, aad_pad_len);
+		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+				"no room to append aad");
 
-static int
-test_kasumi_auth_cipher_verify_test_case_2(void)
-{
-	return test_kasumi_auth_cipher(
-		&kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
-}
+		sym_op->aead.aad.phys_addr =
+				rte_pktmbuf_iova(ut_params->ibuf);
+		memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
+		debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
+			tdata->aad.len);
 
-static int
-test_kasumi_auth_cipher_verify_test_case_2_oop(void)
-{
-	return test_kasumi_auth_cipher(
-		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
-}
+		/* Append IV at the end of the crypto operation*/
+		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+				uint8_t *, IV_OFFSET);
 
-static int
-test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
-{
-	return test_kasumi_auth_cipher_sgl(
-		&kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
-}
+		rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
+		debug_hexdump(stdout, "iv:", iv_ptr,
+			tdata->iv.len);
+	}
 
-static int
-test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
-{
-	return test_kasumi_auth_cipher_sgl(
-		&kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
-}
+	/* Append plaintext/ciphertext */
+	if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
+		plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+		TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
-static int
-test_kasumi_cipher_auth_test_case_1(void)
-{
-	return test_kasumi_cipher_auth(&kasumi_test_case_6);
-}
+		memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+		debug_hexdump(stdout, "plaintext:", plaintext,
+				tdata->plaintext.len);
 
-static int
-test_zuc_encryption_test_case_1(void)
-{
-	return test_zuc_encryption(&zuc_test_case_cipher_193b);
-}
+		if (ut_params->obuf) {
+			ciphertext = (uint8_t *)rte_pktmbuf_append(
+					ut_params->obuf,
+					plaintext_pad_len + aad_pad_len);
+			TEST_ASSERT_NOT_NULL(ciphertext,
+					"no room to append ciphertext");
 
-static int
-test_zuc_encryption_test_case_2(void)
-{
-	return test_zuc_encryption(&zuc_test_case_cipher_800b);
-}
+			memset(ciphertext + aad_pad_len, 0,
+					tdata->ciphertext.len);
+		}
+	} else {
+		plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
+		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+		TEST_ASSERT_NOT_NULL(ciphertext,
+				"no room to append ciphertext");
 
-static int
-test_zuc_encryption_test_case_3(void)
-{
-	return test_zuc_encryption(&zuc_test_case_cipher_1570b);
-}
+		memcpy(ciphertext, tdata->ciphertext.data,
+				tdata->ciphertext.len);
+		debug_hexdump(stdout, "ciphertext:", ciphertext,
+				tdata->ciphertext.len);
 
-static int
-test_zuc_encryption_test_case_4(void)
-{
-	return test_zuc_encryption(&zuc_test_case_cipher_2798b);
-}
+		if (ut_params->obuf) {
+			plaintext = (uint8_t *)rte_pktmbuf_append(
+					ut_params->obuf,
+					plaintext_pad_len + aad_pad_len);
+			TEST_ASSERT_NOT_NULL(plaintext,
+					"no room to append plaintext");
 
-static int
-test_zuc_encryption_test_case_5(void)
-{
-	return test_zuc_encryption(&zuc_test_case_cipher_4019b);
-}
+			memset(plaintext + aad_pad_len, 0,
+					tdata->plaintext.len);
+		}
+	}
 
-static int
-test_zuc_encryption_test_case_6_sgl(void)
-{
-	return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
-}
+	/* Append digest data */
+	if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
+		sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
+				ut_params->obuf ? ut_params->obuf :
+						ut_params->ibuf,
+						tdata->auth_tag.len);
+		TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
+				"no room to append digest");
+		memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
+		sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
+				ut_params->obuf ? ut_params->obuf :
+						ut_params->ibuf,
+						plaintext_pad_len +
+						aad_pad_len);
+	} else {
+		sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
+				ut_params->ibuf, tdata->auth_tag.len);
+		TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
+				"no room to append digest");
+		sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
+				ut_params->ibuf,
+				plaintext_pad_len + aad_pad_len);
 
-static int
-test_zuc_hash_generate_test_case_1(void)
-{
-	return test_zuc_authentication(&zuc_test_case_auth_1b);
-}
+		rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
+			tdata->auth_tag.len);
+		debug_hexdump(stdout, "digest:",
+			sym_op->aead.digest.data,
+			tdata->auth_tag.len);
+	}
 
-static int
-test_zuc_hash_generate_test_case_2(void)
-{
-	return test_zuc_authentication(&zuc_test_case_auth_90b);
-}
+	sym_op->aead.data.length = tdata->plaintext.len;
+	sym_op->aead.data.offset = aad_pad_len;
 
-static int
-test_zuc_hash_generate_test_case_3(void)
-{
-	return test_zuc_authentication(&zuc_test_case_auth_577b);
+	return 0;
 }
 
 static int
-test_zuc_hash_generate_test_case_4(void)
+test_authenticated_encryption(const struct aead_test_data *tdata)
 {
-	return test_zuc_authentication(&zuc_test_case_auth_2079b);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-static int
-test_zuc_hash_generate_test_case_5(void)
-{
-	return test_zuc_authentication(&zuc_test_auth_5670b);
-}
+	int retval;
+	uint8_t *ciphertext, *auth_tag;
+	uint16_t plaintext_pad_len;
+	uint32_t i;
 
-static int
-test_zuc_hash_generate_test_case_6(void)
-{
-	return test_zuc_authentication(&zuc_test_case_auth_128b);
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	const struct rte_cryptodev_symmetric_capability *capability;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	capability = rte_cryptodev_sym_capability_get(
+			ts_params->valid_devs[0], &cap_idx);
+	if (capability == NULL)
+		return -ENOTSUP;
+	if (rte_cryptodev_sym_capability_check_aead(
+			capability, tdata->key.len, tdata->auth_tag.len,
+			tdata->aad.len, tdata->iv.len))
+		return -ENOTSUP;
 
-static int
-test_zuc_hash_generate_test_case_7(void)
-{
-	return test_zuc_authentication(&zuc_test_case_auth_2080b);
-}
-
-static int
-test_zuc_hash_generate_test_case_8(void)
-{
-	return test_zuc_authentication(&zuc_test_case_auth_584b);
-}
-
-static int
-test_zuc_cipher_auth_test_case_1(void)
-{
-	return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
-}
-
-static int
-test_zuc_cipher_auth_test_case_2(void)
-{
-	return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
-}
+	/* Create AEAD session */
+	retval = create_aead_session(ts_params->valid_devs[0],
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_ENCRYPT,
+			tdata->key.data, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
+	if (retval < 0)
+		return retval;
 
-static int
-test_zuc_auth_cipher_test_case_1(void)
-{
-	return test_zuc_auth_cipher(
-		&zuc_auth_cipher_test_case_1, IN_PLACE, 0);
-}
+	if (tdata->aad.len > MBUF_SIZE) {
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+		/* Populate full size of add data */
+		for (i = 32; i < MAX_AAD_LENGTH; i += 32)
+			memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
+	} else
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-static int
-test_zuc_auth_cipher_test_case_1_oop(void)
-{
-	return test_zuc_auth_cipher(
-		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
-}
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-static int
-test_zuc_auth_cipher_test_case_1_sgl(void)
-{
-	return test_zuc_auth_cipher_sgl(
-		&zuc_auth_cipher_test_case_1, IN_PLACE, 0);
-}
+	/* Create AEAD operation */
+	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
+	if (retval < 0)
+		return retval;
 
-static int
-test_zuc_auth_cipher_test_case_1_oop_sgl(void)
-{
-	return test_zuc_auth_cipher_sgl(
-		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
-}
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-static int
-test_zuc_auth_cipher_verify_test_case_1(void)
-{
-	return test_zuc_auth_cipher(
-		&zuc_auth_cipher_test_case_1, IN_PLACE, 1);
-}
+	ut_params->op->sym->m_src = ut_params->ibuf;
 
-static int
-test_zuc_auth_cipher_verify_test_case_1_oop(void)
-{
-	return test_zuc_auth_cipher(
-		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
-}
+	/* Process crypto operation */
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
-static int
-test_zuc_auth_cipher_verify_test_case_1_sgl(void)
-{
-	return test_zuc_auth_cipher_sgl(
-		&zuc_auth_cipher_test_case_1, IN_PLACE, 1);
-}
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
 
-static int
-test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
-{
-	return test_zuc_auth_cipher_sgl(
-		&zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
-}
+	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
 
-static int
-test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
-{
-	uint8_t dev_id = testsuite_params.valid_devs[0];
+	if (ut_params->op->sym->m_dst) {
+		ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
+				uint8_t *);
+		auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
+				uint8_t *, plaintext_pad_len);
+	} else {
+		ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
+				uint8_t *,
+				ut_params->op->sym->cipher.data.offset);
+		auth_tag = ciphertext + plaintext_pad_len;
+	}
 
-	struct rte_cryptodev_sym_capability_idx cap_idx;
+	debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
+	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
 
-	/* Check if device supports particular cipher algorithm */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	cap_idx.algo.cipher = tdata->cipher_algo;
-	if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
-		return -ENOTSUP;
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->ciphertext.len,
+			"Ciphertext data not as expected");
 
-	/* Check if device supports particular hash algorithm */
-	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	cap_idx.algo.auth = tdata->auth_algo;
-	if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
-		return -ENOTSUP;
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			auth_tag,
+			tdata->auth_tag.data,
+			tdata->auth_tag.len,
+			"Generated auth tag not as expected");
 
 	return 0;
+
 }
 
+#ifdef RTE_LIBRTE_SECURITY
+/* Basic algorithm run function for async inplace mode.
+ * Creates a session from input parameters and runs one operation
+ * on input_vec. Checks the output of the crypto operation against
+ * output_vec.
+ */
 static int
-test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
-	uint8_t op_mode, uint8_t verify)
+test_pdcp_proto(int i, int oop,
+	enum rte_crypto_cipher_operation opc,
+	enum rte_crypto_auth_operation opa,
+	uint8_t *input_vec,
+	unsigned int input_vec_len,
+	uint8_t *output_vec,
+	unsigned int output_vec_len)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *plaintext;
+	int ret = TEST_SUCCESS;
 
-	int retval;
-
-	uint8_t *plaintext = NULL, *ciphertext = NULL;
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	unsigned int ciphertext_pad_len;
-	unsigned int ciphertext_len;
-
-	struct rte_cryptodev_info dev_info;
-	struct rte_crypto_op *op;
-
-	/* Check if device supports particular algorithms separately */
-	if (test_mixed_check_if_unsupported(tdata))
-		return -ENOTSUP;
-
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
-
-	uint64_t feat_flags = dev_info.feature_flags;
-
-	if (op_mode == OUT_OF_PLACE) {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
-			printf("Device doesn't support digest encrypted.\n");
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	if (pdcp_test_params[i].auth_alg != 0) {
+		cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+		cap_idx.algo.auth = pdcp_test_params[i].auth_alg;
+		if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+				&cap_idx) == NULL)
 			return -ENOTSUP;
-		}
 	}
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = pdcp_test_params[i].cipher_alg;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* Create the session */
-	if (verify)
-		retval = create_wireless_algo_cipher_auth_session(
-				ts_params->valid_devs[0],
-				RTE_CRYPTO_CIPHER_OP_DECRYPT,
-				RTE_CRYPTO_AUTH_OP_VERIFY,
-				tdata->auth_algo,
-				tdata->cipher_algo,
-				tdata->auth_key.data, tdata->auth_key.len,
-				tdata->auth_iv.len, tdata->digest_enc.len,
-				tdata->cipher_iv.len);
-	else
-		retval = create_wireless_algo_auth_cipher_session(
-				ts_params->valid_devs[0],
-				RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-				RTE_CRYPTO_AUTH_OP_GENERATE,
-				tdata->auth_algo,
-				tdata->cipher_algo,
-				tdata->auth_key.data, tdata->auth_key.len,
-				tdata->auth_iv.len, tdata->digest_enc.len,
-				tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
-
+	/* Generate test mbuf data */
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	if (op_mode == OUT_OF_PLACE)
-		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
 	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-		rte_pktmbuf_tailroom(ut_params->ibuf));
-	if (op_mode == OUT_OF_PLACE)
-		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
-				rte_pktmbuf_tailroom(ut_params->obuf));
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
-	plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+						  input_vec_len);
+	memcpy(plaintext, input_vec, input_vec_len);
 
-	if (verify) {
-		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				ciphertext_pad_len);
-		memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
-		if (op_mode == OUT_OF_PLACE)
-			rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-				ciphertext_len);
-	} else {
-		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-		memcpy(plaintext, tdata->plaintext.data, plaintext_len);
-		if (op_mode == OUT_OF_PLACE)
-			rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
-		debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
+	/* Out of place support */
+	if (oop) {
+		/*
+		 * For out-op-place we need to alloc another mbuf
+		 */
+		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+		rte_pktmbuf_append(ut_params->obuf, output_vec_len);
 	}
 
-	/* Create the operation */
-	if (verify)
-		retval = create_wireless_algo_cipher_hash_operation(
-				tdata->digest_enc.data, tdata->digest_enc.len,
-				tdata->auth_iv.data, tdata->auth_iv.len,
-				plaintext_len, RTE_CRYPTO_AUTH_OP_VERIFY,
-				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				tdata->validCipherLen.len_bits,
-				tdata->cipher.offset_bits,
-				tdata->validAuthLen.len_bits,
-				tdata->auth.offset_bits);
-	else
-		retval = create_wireless_algo_auth_cipher_operation(
-				tdata->digest_enc.len,
-				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				tdata->auth_iv.data, tdata->auth_iv.len,
-				(tdata->digest_enc.offset == 0 ?
-					plaintext_pad_len
-					: tdata->digest_enc.offset),
-				tdata->validCipherLen.len_bits,
-				tdata->cipher.offset_bits,
-				tdata->validAuthLen.len_bits,
-				tdata->auth.offset_bits,
-				op_mode, 0);
-	if (retval < 0)
-		return retval;
+	/* Set crypto type as IPSEC */
+	ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 
-	op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
+	ut_params->cipher_xform.cipher.op = opc;
+	ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
+	ut_params->cipher_xform.cipher.key.length =
+					pdcp_test_params[i].cipher_key_len;
+	ut_params->cipher_xform.cipher.iv.length = 0;
 
-	/* Check if the op failed because the device doesn't */
-	/* support this particular combination of algorithms */
-	if (op == NULL && ut_params->op->status ==
-			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
-		printf("Device doesn't support this mixed combination. "
-				"Test Skipped.\n");
-		return -ENOTSUP;
+	/* Setup HMAC Parameters if ICV header is required */
+	if (pdcp_test_params[i].auth_alg != 0) {
+		ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+		ut_params->auth_xform.next = NULL;
+		ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
+		ut_params->auth_xform.auth.op = opa;
+		ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
+		ut_params->auth_xform.auth.key.length =
+					pdcp_test_params[i].auth_key_len;
+
+		ut_params->cipher_xform.next = &ut_params->auth_xform;
+	} else {
+		ut_params->cipher_xform.next = NULL;
 	}
-	ut_params->op = op;
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+	struct rte_security_session_conf sess_conf = {
+		.action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
+		.protocol = RTE_SECURITY_PROTOCOL_PDCP,
+		{.pdcp = {
+			.bearer = pdcp_test_bearer[i],
+			.domain = pdcp_test_params[i].domain,
+			.pkt_dir = pdcp_test_packet_direction[i],
+			.sn_size = pdcp_test_data_sn_size[i],
+			.hfn = pdcp_test_hfn[i],
+			.hfn_threshold = pdcp_test_hfn_threshold[i],
+		} },
+		.crypto_xform = &ut_params->cipher_xform
+	};
 
-	ut_params->obuf = (op_mode == IN_PLACE ?
-			ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
+	struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+				rte_cryptodev_get_sec_ctx(
+				ts_params->valid_devs[0]);
 
-	if (verify) {
-		if (ut_params->obuf)
-			plaintext = rte_pktmbuf_mtod(ut_params->obuf,
-							uint8_t *);
-		else
-			plaintext = ciphertext +
-					(tdata->cipher.offset_bits >> 3);
+	/* Create security session */
+	ut_params->sec_session = rte_security_session_create(ctx,
+				&sess_conf, ts_params->session_priv_mpool);
 
-		debug_hexdump(stdout, "plaintext:", plaintext,
-				tdata->plaintext.len_bits >> 3);
-		debug_hexdump(stdout, "plaintext expected:",
-				tdata->plaintext.data,
-				tdata->plaintext.len_bits >> 3);
-	} else {
-		if (ut_params->obuf)
-			ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
-					uint8_t *);
-		else
-			ciphertext = plaintext;
+	if (!ut_params->sec_session) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__, "Failed to allocate session");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-				ciphertext_len);
-		debug_hexdump(stdout, "ciphertext expected:",
-				tdata->ciphertext.data,
-				tdata->ciphertext.len_bits >> 3);
+	/* Generate crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	if (!ut_params->op) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__,
+			"Failed to allocate symmetric crypto operation struct");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-		ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
-				+ (tdata->digest_enc.offset == 0 ?
-		plaintext_pad_len : tdata->digest_enc.offset);
+	rte_security_attach_session(ut_params->op, ut_params->sec_session);
 
-		debug_hexdump(stdout, "digest:", ut_params->digest,
-				tdata->digest_enc.len);
-		debug_hexdump(stdout, "digest expected:",
-				tdata->digest_enc.data,
-				tdata->digest_enc.len);
+	/* set crypto operation source mbuf */
+	ut_params->op->sym->m_src = ut_params->ibuf;
+	if (oop)
+		ut_params->op->sym->m_dst = ut_params->obuf;
+
+	/* Process crypto operation */
+	if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
+		== NULL) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__,
+			"failed to process sym crypto op");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
+
+	if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__, "crypto op processing failed");
+		ret = TEST_FAILED;
+		goto on_err;
 	}
 
 	/* Validate obuf */
-	if (verify) {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-				plaintext,
-				tdata->plaintext.data,
-				tdata->plaintext.len_bits >> 3,
-				"Plaintext data not as expected");
-	} else {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-				ciphertext,
-				tdata->ciphertext.data,
-				tdata->validDataLen.len_bits,
-				"Ciphertext data not as expected");
+	uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
+			uint8_t *);
+	if (oop) {
+		ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
+				uint8_t *);
+	}
 
-		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-				ut_params->digest,
-				tdata->digest_enc.data,
-				DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
-				"Generated auth tag not as expected");
+	if (memcmp(ciphertext, output_vec, output_vec_len)) {
+		printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
+		rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
+		rte_hexdump(stdout, "reference", output_vec, output_vec_len);
+		ret = TEST_FAILED;
+		goto on_err;
 	}
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
+on_err:
+	rte_crypto_op_free(ut_params->op);
+	ut_params->op = NULL;
 
-	return 0;
+	if (ut_params->sec_session)
+		rte_security_session_destroy(ctx, ut_params->sec_session);
+	ut_params->sec_session = NULL;
+
+	rte_pktmbuf_free(ut_params->ibuf);
+	ut_params->ibuf = NULL;
+	if (oop) {
+		rte_pktmbuf_free(ut_params->obuf);
+		ut_params->obuf = NULL;
+	}
+
+	return ret;
 }
 
 static int
-test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
-	uint8_t op_mode, uint8_t verify)
+test_pdcp_proto_SGL(int i, int oop,
+	enum rte_crypto_cipher_operation opc,
+	enum rte_crypto_auth_operation opa,
+	uint8_t *input_vec,
+	unsigned int input_vec_len,
+	uint8_t *output_vec,
+	unsigned int output_vec_len,
+	uint32_t fragsz,
+	uint32_t fragsz_oop)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *plaintext;
+	struct rte_mbuf *buf, *buf_oop = NULL;
+	int ret = TEST_SUCCESS;
+	int to_trn = 0;
+	int to_trn_tbl[16];
+	int segs = 1;
+	unsigned int trn_data = 0;
 
-	int retval;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	if (pdcp_test_params[i].auth_alg != 0) {
+		cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+		cap_idx.algo.auth = pdcp_test_params[i].auth_alg;
+		if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+				&cap_idx) == NULL)
+			return -ENOTSUP;
+	}
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = pdcp_test_params[i].cipher_alg;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	const uint8_t *plaintext = NULL;
-	const uint8_t *ciphertext = NULL;
-	const uint8_t *digest = NULL;
-	unsigned int plaintext_pad_len;
-	unsigned int plaintext_len;
-	unsigned int ciphertext_pad_len;
-	unsigned int ciphertext_len;
-	uint8_t buffer[10000];
-	uint8_t digest_buffer[10000];
+	if (fragsz > input_vec_len)
+		fragsz = input_vec_len;
 
-	struct rte_cryptodev_info dev_info;
-	struct rte_crypto_op *op;
+	uint16_t plaintext_len = fragsz;
+	uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
 
-	/* Check if device supports particular algorithms */
-	if (test_mixed_check_if_unsupported(tdata))
-		return -ENOTSUP;
+	if (fragsz_oop > output_vec_len)
+		frag_size_oop = output_vec_len;
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	int ecx = 0;
+	if (input_vec_len % fragsz != 0) {
+		if (input_vec_len / fragsz + 1 > 16)
+			return 1;
+	} else if (input_vec_len / fragsz > 16)
+		return 1;
 
-	uint64_t feat_flags = dev_info.feature_flags;
+	/* Out of place support */
+	if (oop) {
+		/*
+		 * For out-op-place we need to alloc another mbuf
+		 */
+		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+		rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
+		buf_oop = ut_params->obuf;
+	}
 
-	if (op_mode == IN_PLACE) {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
-			printf("Device doesn't support in-place scatter-gather "
-					"in both input and output mbufs.\n");
-			return -ENOTSUP;
-		}
-	} else {
-		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
-			printf("Device doesn't support out-of-place scatter-gather "
-					"in both input and output mbufs.\n");
-			return -ENOTSUP;
-		}
-		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
-			printf("Device doesn't support digest encrypted.\n");
-			return -ENOTSUP;
-		}
-	}
+	/* Generate test mbuf data */
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* Create the session */
-	if (verify)
-		retval = create_wireless_algo_cipher_auth_session(
-				ts_params->valid_devs[0],
-				RTE_CRYPTO_CIPHER_OP_DECRYPT,
-				RTE_CRYPTO_AUTH_OP_VERIFY,
-				tdata->auth_algo,
-				tdata->cipher_algo,
-				tdata->auth_key.data, tdata->auth_key.len,
-				tdata->auth_iv.len, tdata->digest_enc.len,
-				tdata->cipher_iv.len);
-	else
-		retval = create_wireless_algo_auth_cipher_session(
-				ts_params->valid_devs[0],
-				RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-				RTE_CRYPTO_AUTH_OP_GENERATE,
-				tdata->auth_algo,
-				tdata->cipher_algo,
-				tdata->auth_key.data, tdata->auth_key.len,
-				tdata->auth_iv.len, tdata->digest_enc.len,
-				tdata->cipher_iv.len);
-	if (retval < 0)
-		return retval;
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
-	plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
-	ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
-	plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+						  plaintext_len);
+	memcpy(plaintext, input_vec, plaintext_len);
+	trn_data += plaintext_len;
 
-	ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
-			ciphertext_pad_len, 15, 0);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
+	buf = ut_params->ibuf;
 
-	if (op_mode == OUT_OF_PLACE) {
-		ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
-				plaintext_pad_len, 15, 0);
-		TEST_ASSERT_NOT_NULL(ut_params->obuf,
-				"Failed to allocate output buffer in mempool");
-	}
+	/*
+	 * Loop until no more fragments
+	 */
 
-	if (verify) {
-		pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
-			tdata->ciphertext.data);
-		ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					ciphertext_len, buffer);
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
-	} else {
-		pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
-			tdata->plaintext.data);
-		plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					plaintext_len, buffer);
-		debug_hexdump(stdout, "plaintext:", plaintext,
-			plaintext_len);
-	}
-	memset(buffer, 0, sizeof(buffer));
+	while (trn_data < input_vec_len) {
+		++segs;
+		to_trn = (input_vec_len - trn_data < fragsz) ?
+				(input_vec_len - trn_data) : fragsz;
 
-	/* Create the operation */
-	if (verify)
-		retval = create_wireless_algo_cipher_hash_operation(
-				tdata->digest_enc.data, tdata->digest_enc.len,
-				tdata->auth_iv.data, tdata->auth_iv.len,
-				plaintext_len, RTE_CRYPTO_AUTH_OP_VERIFY,
-				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				tdata->validCipherLen.len_bits,
-				tdata->cipher.offset_bits,
-				tdata->validAuthLen.len_bits,
-				tdata->auth.offset_bits);
-	else
-		retval = create_wireless_algo_auth_cipher_operation(
-				tdata->digest_enc.len,
-				tdata->cipher_iv.data, tdata->cipher_iv.len,
-				tdata->auth_iv.data, tdata->auth_iv.len,
-				(tdata->digest_enc.offset == 0 ?
-					plaintext_pad_len
-					: tdata->digest_enc.offset),
-				tdata->validCipherLen.len_bits,
-				tdata->cipher.offset_bits,
-				tdata->validAuthLen.len_bits,
-				tdata->auth.offset_bits,
-				op_mode, 1);
-	if (retval < 0)
-		return retval;
+		to_trn_tbl[ecx++] = to_trn;
 
-	op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+		buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+		buf = buf->next;
 
-	/* Check if the op failed because the device doesn't */
-	/* support this particular combination of algorithms */
-	if (op == NULL && ut_params->op->status ==
-			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
-		printf("Device doesn't support this mixed combination. "
-				"Test Skipped.\n");
-		return -ENOTSUP;
-	}
+		memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
+				rte_pktmbuf_tailroom(buf));
 
-	ut_params->op = op;
+		/* OOP */
+		if (oop && !fragsz_oop) {
+			buf_oop->next =
+					rte_pktmbuf_alloc(ts_params->mbuf_pool);
+			buf_oop = buf_oop->next;
+			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
+					0, rte_pktmbuf_tailroom(buf_oop));
+			rte_pktmbuf_append(buf_oop, to_trn);
+		}
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
+		plaintext = (uint8_t *)rte_pktmbuf_append(buf,
+				to_trn);
 
-	ut_params->obuf = (op_mode == IN_PLACE ?
-			ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
+		memcpy(plaintext, input_vec + trn_data, to_trn);
+		trn_data += to_trn;
+	}
 
-	if (verify) {
-		if (ut_params->obuf)
-			plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
-					plaintext_len, buffer);
-		else
-			plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					plaintext_len, buffer);
+	ut_params->ibuf->nb_segs = segs;
 
-		debug_hexdump(stdout, "plaintext:", plaintext,
-				(tdata->plaintext.len_bits >> 3) -
-				tdata->digest_enc.len);
-		debug_hexdump(stdout, "plaintext expected:",
-				tdata->plaintext.data,
-				(tdata->plaintext.len_bits >> 3) -
-				tdata->digest_enc.len);
-	} else {
-		if (ut_params->obuf)
-			ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
-					ciphertext_len, buffer);
-		else
-			ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
-					ciphertext_len, buffer);
+	segs = 1;
+	if (fragsz_oop && oop) {
+		to_trn = 0;
+		ecx = 0;
 
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-			ciphertext_len);
-		debug_hexdump(stdout, "ciphertext expected:",
-			tdata->ciphertext.data,
-			tdata->ciphertext.len_bits >> 3);
+		trn_data = frag_size_oop;
+		while (trn_data < output_vec_len) {
+			++segs;
+			to_trn =
+				(output_vec_len - trn_data <
+						frag_size_oop) ?
+				(output_vec_len - trn_data) :
+						frag_size_oop;
 
-		if (ut_params->obuf)
-			digest = rte_pktmbuf_read(ut_params->obuf,
-					(tdata->digest_enc.offset == 0 ?
-						plaintext_pad_len :
-						tdata->digest_enc.offset),
-					tdata->digest_enc.len, digest_buffer);
-		else
-			digest = rte_pktmbuf_read(ut_params->ibuf,
-					(tdata->digest_enc.offset == 0 ?
-						plaintext_pad_len :
-						tdata->digest_enc.offset),
-					tdata->digest_enc.len, digest_buffer);
+			to_trn_tbl[ecx++] = to_trn;
 
-		debug_hexdump(stdout, "digest:", digest,
-				tdata->digest_enc.len);
-		debug_hexdump(stdout, "digest expected:",
-				tdata->digest_enc.data, tdata->digest_enc.len);
-	}
+			buf_oop->next =
+				rte_pktmbuf_alloc(ts_params->mbuf_pool);
+			buf_oop = buf_oop->next;
+			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
+					0, rte_pktmbuf_tailroom(buf_oop));
+			rte_pktmbuf_append(buf_oop, to_trn);
 
-	/* Validate obuf */
-	if (verify) {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-				plaintext,
-				tdata->plaintext.data,
-				tdata->plaintext.len_bits >> 3,
-				"Plaintext data not as expected");
-	} else {
-		TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-				ciphertext,
-				tdata->ciphertext.data,
-				tdata->validDataLen.len_bits,
-				"Ciphertext data not as expected");
-		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-				digest,
-				tdata->digest_enc.data,
-				tdata->digest_enc.len,
-				"Generated auth tag not as expected");
+			trn_data += to_trn;
+		}
+		ut_params->obuf->nb_segs = segs;
 	}
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
+	ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 
-	return 0;
-}
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
+	ut_params->cipher_xform.cipher.op = opc;
+	ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
+	ut_params->cipher_xform.cipher.key.length =
+					pdcp_test_params[i].cipher_key_len;
+	ut_params->cipher_xform.cipher.iv.length = 0;
 
-/** AUTH AES CMAC + CIPHER AES CTR */
+	/* Setup HMAC Parameters if ICV header is required */
+	if (pdcp_test_params[i].auth_alg != 0) {
+		ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+		ut_params->auth_xform.next = NULL;
+		ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
+		ut_params->auth_xform.auth.op = opa;
+		ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
+		ut_params->auth_xform.auth.key.length =
+					pdcp_test_params[i].auth_key_len;
 
-static int
-test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
-}
+		ut_params->cipher_xform.next = &ut_params->auth_xform;
+	} else {
+		ut_params->cipher_xform.next = NULL;
+	}
 
-static int
-test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
-}
+	struct rte_security_session_conf sess_conf = {
+		.action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
+		.protocol = RTE_SECURITY_PROTOCOL_PDCP,
+		{.pdcp = {
+			.bearer = pdcp_test_bearer[i],
+			.domain = pdcp_test_params[i].domain,
+			.pkt_dir = pdcp_test_packet_direction[i],
+			.sn_size = pdcp_test_data_sn_size[i],
+			.hfn = pdcp_test_hfn[i],
+			.hfn_threshold = pdcp_test_hfn_threshold[i],
+		} },
+		.crypto_xform = &ut_params->cipher_xform
+	};
 
-static int
-test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
-{
-	return test_mixed_auth_cipher_sgl(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
-}
+	struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+				rte_cryptodev_get_sec_ctx(
+				ts_params->valid_devs[0]);
 
-static int
-test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
-{
-	return test_mixed_auth_cipher_sgl(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
-}
+	/* Create security session */
+	ut_params->sec_session = rte_security_session_create(ctx,
+				&sess_conf, ts_params->session_priv_mpool);
 
-static int
-test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
-}
+	if (!ut_params->sec_session) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__, "Failed to allocate session");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-static int
-test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
-}
+	/* Generate crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	if (!ut_params->op) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__,
+			"Failed to allocate symmetric crypto operation struct");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-static int
-test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
-{
-	return test_mixed_auth_cipher_sgl(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
-}
+	rte_security_attach_session(ut_params->op, ut_params->sec_session);
 
-static int
-test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
-{
-	return test_mixed_auth_cipher_sgl(
-		&auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
-}
+	/* set crypto operation source mbuf */
+	ut_params->op->sym->m_src = ut_params->ibuf;
+	if (oop)
+		ut_params->op->sym->m_dst = ut_params->obuf;
 
-/** MIXED AUTH + CIPHER */
+	/* Process crypto operation */
+	if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
+		== NULL) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__,
+			"failed to process sym crypto op");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-static int
-test_auth_zuc_cipher_snow_test_case_1(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
-}
+	if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
+		printf("TestCase %s()-%d line %d failed %s: ",
+			__func__, i, __LINE__, "crypto op processing failed");
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-static int
-test_verify_auth_zuc_cipher_snow_test_case_1(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
-}
+	/* Validate obuf */
+	uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
+			uint8_t *);
+	if (oop) {
+		ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
+				uint8_t *);
+	}
+	if (fragsz_oop)
+		fragsz = frag_size_oop;
+	if (memcmp(ciphertext, output_vec, fragsz)) {
+		printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
+		rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
+		rte_hexdump(stdout, "reference", output_vec, fragsz);
+		ret = TEST_FAILED;
+		goto on_err;
+	}
 
-static int
-test_auth_aes_cmac_cipher_snow_test_case_1(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
-}
+	buf = ut_params->op->sym->m_src->next;
+	if (oop)
+		buf = ut_params->op->sym->m_dst->next;
 
-static int
-test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
-{
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
+	unsigned int off = fragsz;
+
+	ecx = 0;
+	while (buf) {
+		ciphertext = rte_pktmbuf_mtod(buf,
+				uint8_t *);
+		if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
+			printf("\n=======PDCP TestCase #%d failed: Data Mismatch ",
+					i);
+			rte_hexdump(stdout, "encrypted", ciphertext,
+					to_trn_tbl[ecx]);
+			rte_hexdump(stdout, "reference", output_vec + off,
+					to_trn_tbl[ecx]);
+			ret = TEST_FAILED;
+			goto on_err;
+		}
+		off += to_trn_tbl[ecx++];
+		buf = buf->next;
+	}
+on_err:
+	rte_crypto_op_free(ut_params->op);
+	ut_params->op = NULL;
+
+	if (ut_params->sec_session)
+		rte_security_session_destroy(ctx, ut_params->sec_session);
+	ut_params->sec_session = NULL;
+
+	rte_pktmbuf_free(ut_params->ibuf);
+	ut_params->ibuf = NULL;
+	if (oop) {
+		rte_pktmbuf_free(ut_params->obuf);
+		ut_params->obuf = NULL;
+	}
+
+	return ret;
 }
 
-static int
-test_auth_zuc_cipher_aes_ctr_test_case_1(void)
+int
+test_pdcp_proto_cplane_encap(int i)
 {
-	return test_mixed_auth_cipher(
-		&auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
+	return test_pdcp_proto(i, 0,
+		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+		RTE_CRYPTO_AUTH_OP_GENERATE,
+		pdcp_test_data_in[i],
+		pdcp_test_data_in_len[i],
+		pdcp_test_data_out[i],
+		pdcp_test_data_in_len[i]+4);
 }
 
-static int
-test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
+int
+test_pdcp_proto_uplane_encap(int i)
 {
-	return test_mixed_auth_cipher(
-		&auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
+	return test_pdcp_proto(i, 0,
+		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+		RTE_CRYPTO_AUTH_OP_GENERATE,
+		pdcp_test_data_in[i],
+		pdcp_test_data_in_len[i],
+		pdcp_test_data_out[i],
+		pdcp_test_data_in_len[i]);
+
 }
 
-static int
-test_auth_snow_cipher_aes_ctr_test_case_1(void)
+int
+test_pdcp_proto_uplane_encap_with_int(int i)
 {
-	return test_mixed_auth_cipher(
-		&auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
+	return test_pdcp_proto(i, 0,
+		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+		RTE_CRYPTO_AUTH_OP_GENERATE,
+		pdcp_test_data_in[i],
+		pdcp_test_data_in_len[i],
+		pdcp_test_data_out[i],
+		pdcp_test_data_in_len[i] + 4);
 }
 
-static int
-test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
+int
+test_pdcp_proto_cplane_decap(int i)
 {
-	return test_mixed_auth_cipher(
-		&auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
+	return test_pdcp_proto(i, 0,
+		RTE_CRYPTO_CIPHER_OP_DECRYPT,
+		RTE_CRYPTO_AUTH_OP_VERIFY,
+		pdcp_test_data_out[i],
+		pdcp_test_data_in_len[i] + 4,
+		pdcp_test_data_in[i],
+		pdcp_test_data_in_len[i]);
 }
 
-static int
-test_auth_snow_cipher_zuc_test_case_1(void)
+int
+test_pdcp_proto_uplane_decap(int i)
 {
-	return test_mixed_auth_cipher(
-		&auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
+	return test_pdcp_proto(i, 0,
+		RTE_CRYPTO_CIPHER_OP_DECRYPT,
+		RTE_CRYPTO_AUTH_OP_VERIFY,
+		pdcp_test_data_out[i],
+		pdcp_test_data_in_len[i],
+		pdcp_test_data_in[i],
+		pdcp_test_data_in_len[i]);
 }
 
-static int
-test_verify_auth_snow_cipher_zuc_test_case_1(void)
+int
+test_pdcp_proto_uplane_decap_with_int(int i)
 {
-	return test_mixed_auth_cipher(
-		&auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
+	return test_pdcp_proto(i, 0,
+		RTE_CRYPTO_CIPHER_OP_DECRYPT,
+		RTE_CRYPTO_AUTH_OP_VERIFY,
+		pdcp_test_data_out[i],
+		pdcp_test_data_in_len[i] + 4,
+		pdcp_test_data_in[i],
+		pdcp_test_data_in_len[i]);
 }
 
 static int
-test_auth_aes_cmac_cipher_zuc_test_case_1(void)
+test_PDCP_PROTO_SGL_in_place_32B(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
+	/* i can be used for running any PDCP case
+	 * In this case it is uplane 12-bit AES-SNOW DL encap
+	 */
+	int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
+	return test_pdcp_proto_SGL(i, IN_PLACE,
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			pdcp_test_data_in[i],
+			pdcp_test_data_in_len[i],
+			pdcp_test_data_out[i],
+			pdcp_test_data_in_len[i]+4,
+			32, 0);
 }
-
 static int
-test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
+test_PDCP_PROTO_SGL_oop_32B_128B(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
+	/* i can be used for running any PDCP case
+	 * In this case it is uplane 18-bit NULL-NULL DL encap
+	 */
+	int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
+	return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			pdcp_test_data_in[i],
+			pdcp_test_data_in_len[i],
+			pdcp_test_data_out[i],
+			pdcp_test_data_in_len[i]+4,
+			32, 128);
 }
-
 static int
-test_auth_null_cipher_snow_test_case_1(void)
+test_PDCP_PROTO_SGL_oop_32B_40B(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
+	/* i can be used for running any PDCP case
+	 * In this case it is uplane 18-bit AES DL encap
+	 */
+	int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
+			+ DOWNLINK;
+	return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			pdcp_test_data_in[i],
+			pdcp_test_data_in_len[i],
+			pdcp_test_data_out[i],
+			pdcp_test_data_in_len[i],
+			32, 40);
 }
-
 static int
-test_verify_auth_null_cipher_snow_test_case_1(void)
+test_PDCP_PROTO_SGL_oop_128B_32B(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
+	/* i can be used for running any PDCP case
+	 * In this case it is cplane 12-bit AES-ZUC DL encap
+	 */
+	int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
+	return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
+			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+			RTE_CRYPTO_AUTH_OP_GENERATE,
+			pdcp_test_data_in[i],
+			pdcp_test_data_in_len[i],
+			pdcp_test_data_out[i],
+			pdcp_test_data_in_len[i]+4,
+			128, 32);
 }
+#endif
 
 static int
-test_auth_null_cipher_zuc_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_1(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
+	return test_authenticated_encryption(&gcm_test_case_1);
 }
 
 static int
-test_verify_auth_null_cipher_zuc_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_2(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
+	return test_authenticated_encryption(&gcm_test_case_2);
 }
 
 static int
-test_auth_snow_cipher_null_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_3(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
+	return test_authenticated_encryption(&gcm_test_case_3);
 }
 
 static int
-test_verify_auth_snow_cipher_null_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_4(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
+	return test_authenticated_encryption(&gcm_test_case_4);
 }
 
 static int
-test_auth_zuc_cipher_null_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_5(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
+	return test_authenticated_encryption(&gcm_test_case_5);
 }
 
 static int
-test_verify_auth_zuc_cipher_null_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_6(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
+	return test_authenticated_encryption(&gcm_test_case_6);
 }
 
 static int
-test_auth_null_cipher_aes_ctr_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_7(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
+	return test_authenticated_encryption(&gcm_test_case_7);
 }
 
 static int
-test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_8(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
+	return test_authenticated_encryption(&gcm_test_case_8);
 }
 
 static int
-test_auth_aes_cmac_cipher_null_test_case_1(void)
+test_AES_GCM_auth_encryption_test_case_192_1(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
+	return test_authenticated_encryption(&gcm_test_case_192_1);
 }
 
 static int
-test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
+test_AES_GCM_auth_encryption_test_case_192_2(void)
 {
-	return test_mixed_auth_cipher(
-		&auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
+	return test_authenticated_encryption(&gcm_test_case_192_2);
 }
 
 static int
-test_3DES_chain_qat_all(void)
+test_AES_GCM_auth_encryption_test_case_192_3(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_192_3);
 }
 
 static int
-test_DES_cipheronly_qat_all(void)
+test_AES_GCM_auth_encryption_test_case_192_4(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_192_4);
 }
 
 static int
-test_DES_cipheronly_openssl_all(void)
+test_AES_GCM_auth_encryption_test_case_192_5(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_192_5);
 }
 
 static int
-test_DES_docsis_openssl_all(void)
+test_AES_GCM_auth_encryption_test_case_192_6(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_DES_DOCSIS_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_192_6);
 }
 
 static int
-test_DES_cipheronly_mb_all(void)
+test_AES_GCM_auth_encryption_test_case_192_7(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_192_7);
 }
+
 static int
-test_3DES_cipheronly_mb_all(void)
+test_AES_GCM_auth_encryption_test_case_256_1(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_256_1);
 }
 
 static int
-test_DES_docsis_mb_all(void)
+test_AES_GCM_auth_encryption_test_case_256_2(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
-		BLKCIPHER_DES_DOCSIS_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_256_2);
 }
 
 static int
-test_3DES_chain_caam_jr_all(void)
+test_AES_GCM_auth_encryption_test_case_256_3(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_256_3);
 }
 
 static int
-test_3DES_cipheronly_caam_jr_all(void)
+test_AES_GCM_auth_encryption_test_case_256_4(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+	return test_authenticated_encryption(&gcm_test_case_256_4);
 }
 
 static int
-test_3DES_chain_dpaa_sec_all(void)
+test_AES_GCM_auth_encryption_test_case_256_5(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	return test_authenticated_encryption(&gcm_test_case_256_5);
+}
 
-	return TEST_SUCCESS;
+static int
+test_AES_GCM_auth_encryption_test_case_256_6(void)
+{
+	return test_authenticated_encryption(&gcm_test_case_256_6);
 }
 
 static int
-test_3DES_cipheronly_dpaa_sec_all(void)
+test_AES_GCM_auth_encryption_test_case_256_7(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	return test_authenticated_encryption(&gcm_test_case_256_7);
+}
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
-
-	return TEST_SUCCESS;
+static int
+test_AES_GCM_auth_encryption_test_case_aad_1(void)
+{
+	return test_authenticated_encryption(&gcm_test_case_aad_1);
 }
 
 static int
-test_3DES_chain_dpaa2_sec_all(void)
+test_AES_GCM_auth_encryption_test_case_aad_2(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
+	return test_authenticated_encryption(&gcm_test_case_aad_2);
+}
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+static int
+test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
+{
+	struct aead_test_data tdata;
+	int res;
 
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.iv.data[0] += 1;
+	res = test_authenticated_encryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
 	return TEST_SUCCESS;
 }
 
 static int
-test_3DES_cipheronly_dpaa2_sec_all(void)
+test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	struct aead_test_data tdata;
+	int res;
 
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.plaintext.data[0] += 1;
+	res = test_authenticated_encryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
 	return TEST_SUCCESS;
 }
 
 static int
-test_3DES_chain_ccp_all(void)
+test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	struct aead_test_data tdata;
+	int res;
 
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.ciphertext.data[0] += 1;
+	res = test_authenticated_encryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
 	return TEST_SUCCESS;
 }
 
 static int
-test_3DES_cipheronly_ccp_all(void)
+test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_CCP_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	struct aead_test_data tdata;
+	int res;
 
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.aad.len += 1;
+	res = test_authenticated_encryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
 	return TEST_SUCCESS;
 }
 
 static int
-test_3DES_cipheronly_qat_all(void)
+test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	struct aead_test_data tdata;
+	uint8_t aad[gcm_test_case_7.aad.len];
+	int res;
 
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
+	aad[0] += 1;
+	tdata.aad.data = aad;
+	res = test_authenticated_encryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
 	return TEST_SUCCESS;
 }
 
 static int
-test_3DES_chain_openssl_all(void)
+test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
-
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_3DES_CHAIN_TYPE);
-
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	struct aead_test_data tdata;
+	int res;
 
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.auth_tag.data[0] += 1;
+	res = test_authenticated_encryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
 	return TEST_SUCCESS;
 }
 
 static int
-test_3DES_cipheronly_openssl_all(void)
+test_authenticated_decryption(const struct aead_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	int status;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-		ts_params->op_mpool,
-		ts_params->session_mpool, ts_params->session_priv_mpool,
-		ts_params->valid_devs[0],
-		rte_cryptodev_driver_id_get(
-		RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
-		BLKCIPHER_3DES_CIPHERONLY_TYPE);
+	int retval;
+	uint8_t *plaintext;
+	uint32_t i;
 
-	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	const struct rte_cryptodev_symmetric_capability *capability;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	capability = rte_cryptodev_sym_capability_get(
+			ts_params->valid_devs[0], &cap_idx);
+	if (capability == NULL)
+		return -ENOTSUP;
+	if (rte_cryptodev_sym_capability_check_aead(
+			capability, tdata->key.len, tdata->auth_tag.len,
+			tdata->aad.len, tdata->iv.len))
+		return -ENOTSUP;
 
-	return TEST_SUCCESS;
-}
+	/* Create AEAD session */
+	retval = create_aead_session(ts_params->valid_devs[0],
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_DECRYPT,
+			tdata->key.data, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
+	if (retval < 0)
+		return retval;
 
-/* ***** AEAD algorithm Tests ***** */
+	/* alloc mbuf and set payload */
+	if (tdata->aad.len > MBUF_SIZE) {
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+		/* Populate full size of add data */
+		for (i = 32; i < MAX_AAD_LENGTH; i += 32)
+			memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
+	} else
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-static int
-create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
-		enum rte_crypto_aead_operation op,
-		const uint8_t *key, const uint8_t key_len,
-		const uint16_t aad_len, const uint8_t auth_len,
-		uint8_t iv_len)
-{
-	uint8_t aead_key[key_len];
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	/* Create AEAD operation */
+	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
+	if (retval < 0)
+		return retval;
 
-	memcpy(aead_key, key, key_len);
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	/* Setup AEAD Parameters */
-	ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
-	ut_params->aead_xform.next = NULL;
-	ut_params->aead_xform.aead.algo = algo;
-	ut_params->aead_xform.aead.op = op;
-	ut_params->aead_xform.aead.key.data = aead_key;
-	ut_params->aead_xform.aead.key.length = key_len;
-	ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
-	ut_params->aead_xform.aead.iv.length = iv_len;
-	ut_params->aead_xform.aead.digest_length = auth_len;
-	ut_params->aead_xform.aead.aad_length = aad_len;
+	ut_params->op->sym->m_src = ut_params->ibuf;
 
-	debug_hexdump(stdout, "key:", key, key_len);
+	/* Process crypto operation */
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
 
-	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->aead_xform,
-			ts_params->session_priv_mpool);
+	if (ut_params->op->sym->m_dst)
+		plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
+				uint8_t *);
+	else
+		plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
+				uint8_t *,
+				ut_params->op->sym->cipher.data.offset);
 
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len,
+			"Plaintext data not as expected");
+
+	TEST_ASSERT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"Authentication failed");
 
 	return 0;
 }
 
 static int
-create_aead_xform(struct rte_crypto_op *op,
-		enum rte_crypto_aead_algorithm algo,
-		enum rte_crypto_aead_operation aead_op,
-		uint8_t *key, const uint8_t key_len,
-		const uint8_t aad_len, const uint8_t auth_len,
-		uint8_t iv_len)
+test_AES_GCM_authenticated_decryption_test_case_1(void)
 {
-	TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
-			"failed to allocate space for crypto transform");
-
-	struct rte_crypto_sym_op *sym_op = op->sym;
-
-	/* Setup AEAD Parameters */
-	sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
-	sym_op->xform->next = NULL;
-	sym_op->xform->aead.algo = algo;
-	sym_op->xform->aead.op = aead_op;
-	sym_op->xform->aead.key.data = key;
-	sym_op->xform->aead.key.length = key_len;
-	sym_op->xform->aead.iv.offset = IV_OFFSET;
-	sym_op->xform->aead.iv.length = iv_len;
-	sym_op->xform->aead.digest_length = auth_len;
-	sym_op->xform->aead.aad_length = aad_len;
-
-	debug_hexdump(stdout, "key:", key, key_len);
+	return test_authenticated_decryption(&gcm_test_case_1);
+}
 
-	return 0;
+static int
+test_AES_GCM_authenticated_decryption_test_case_2(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_2);
 }
 
 static int
-create_aead_operation(enum rte_crypto_aead_operation op,
-		const struct aead_test_data *tdata)
+test_AES_GCM_authenticated_decryption_test_case_3(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_authenticated_decryption(&gcm_test_case_3);
+}
 
-	uint8_t *plaintext, *ciphertext;
-	unsigned int aad_pad_len, plaintext_pad_len;
+static int
+test_AES_GCM_authenticated_decryption_test_case_4(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_4);
+}
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
+static int
+test_AES_GCM_authenticated_decryption_test_case_5(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_5);
+}
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+static int
+test_AES_GCM_authenticated_decryption_test_case_6(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_6);
+}
 
-	/* Append aad data */
-	if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
-		aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
-		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				aad_pad_len);
-		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
-				"no room to append aad");
+static int
+test_AES_GCM_authenticated_decryption_test_case_7(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_7);
+}
 
-		sym_op->aead.aad.phys_addr =
-				rte_pktmbuf_iova(ut_params->ibuf);
-		/* Copy AAD 18 bytes after the AAD pointer, according to the API */
-		memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
-		debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
-			tdata->aad.len);
+static int
+test_AES_GCM_authenticated_decryption_test_case_8(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_8);
+}
 
-		/* Append IV at the end of the crypto operation*/
-		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-				uint8_t *, IV_OFFSET);
+static int
+test_AES_GCM_auth_decryption_test_case_192_1(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_1);
+}
 
-		/* Copy IV 1 byte after the IV pointer, according to the API */
-		rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
-		debug_hexdump(stdout, "iv:", iv_ptr,
-			tdata->iv.len);
-	} else {
-		aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
-		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				aad_pad_len);
-		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
-				"no room to append aad");
+static int
+test_AES_GCM_auth_decryption_test_case_192_2(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_2);
+}
 
-		sym_op->aead.aad.phys_addr =
-				rte_pktmbuf_iova(ut_params->ibuf);
-		memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
-		debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
-			tdata->aad.len);
+static int
+test_AES_GCM_auth_decryption_test_case_192_3(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_3);
+}
 
-		/* Append IV at the end of the crypto operation*/
-		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-				uint8_t *, IV_OFFSET);
+static int
+test_AES_GCM_auth_decryption_test_case_192_4(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_4);
+}
 
-		rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
-		debug_hexdump(stdout, "iv:", iv_ptr,
-			tdata->iv.len);
-	}
+static int
+test_AES_GCM_auth_decryption_test_case_192_5(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_5);
+}
 
-	/* Append plaintext/ciphertext */
-	if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
-		plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
-		plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-		TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+static int
+test_AES_GCM_auth_decryption_test_case_192_6(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_6);
+}
 
-		memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
-		debug_hexdump(stdout, "plaintext:", plaintext,
-				tdata->plaintext.len);
+static int
+test_AES_GCM_auth_decryption_test_case_192_7(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_192_7);
+}
 
-		if (ut_params->obuf) {
-			ciphertext = (uint8_t *)rte_pktmbuf_append(
-					ut_params->obuf,
-					plaintext_pad_len + aad_pad_len);
-			TEST_ASSERT_NOT_NULL(ciphertext,
-					"no room to append ciphertext");
+static int
+test_AES_GCM_auth_decryption_test_case_256_1(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_1);
+}
 
-			memset(ciphertext + aad_pad_len, 0,
-					tdata->ciphertext.len);
-		}
-	} else {
-		plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
-		ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
-		TEST_ASSERT_NOT_NULL(ciphertext,
-				"no room to append ciphertext");
+static int
+test_AES_GCM_auth_decryption_test_case_256_2(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_2);
+}
 
-		memcpy(ciphertext, tdata->ciphertext.data,
-				tdata->ciphertext.len);
-		debug_hexdump(stdout, "ciphertext:", ciphertext,
-				tdata->ciphertext.len);
+static int
+test_AES_GCM_auth_decryption_test_case_256_3(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_3);
+}
 
-		if (ut_params->obuf) {
-			plaintext = (uint8_t *)rte_pktmbuf_append(
-					ut_params->obuf,
-					plaintext_pad_len + aad_pad_len);
-			TEST_ASSERT_NOT_NULL(plaintext,
-					"no room to append plaintext");
+static int
+test_AES_GCM_auth_decryption_test_case_256_4(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_4);
+}
 
-			memset(plaintext + aad_pad_len, 0,
-					tdata->plaintext.len);
-		}
-	}
+static int
+test_AES_GCM_auth_decryption_test_case_256_5(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_5);
+}
 
-	/* Append digest data */
-	if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
-		sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
-				ut_params->obuf ? ut_params->obuf :
-						ut_params->ibuf,
-						tdata->auth_tag.len);
-		TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
-				"no room to append digest");
-		memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
-		sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
-				ut_params->obuf ? ut_params->obuf :
-						ut_params->ibuf,
-						plaintext_pad_len +
-						aad_pad_len);
-	} else {
-		sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
-				ut_params->ibuf, tdata->auth_tag.len);
-		TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
-				"no room to append digest");
-		sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
-				ut_params->ibuf,
-				plaintext_pad_len + aad_pad_len);
+static int
+test_AES_GCM_auth_decryption_test_case_256_6(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_6);
+}
 
-		rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
-			tdata->auth_tag.len);
-		debug_hexdump(stdout, "digest:",
-			sym_op->aead.digest.data,
-			tdata->auth_tag.len);
-	}
+static int
+test_AES_GCM_auth_decryption_test_case_256_7(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_256_7);
+}
 
-	sym_op->aead.data.length = tdata->plaintext.len;
-	sym_op->aead.data.offset = aad_pad_len;
+static int
+test_AES_GCM_auth_decryption_test_case_aad_1(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_aad_1);
+}
 
-	return 0;
+static int
+test_AES_GCM_auth_decryption_test_case_aad_2(void)
+{
+	return test_authenticated_decryption(&gcm_test_case_aad_2);
 }
 
 static int
-test_authenticated_encryption(const struct aead_test_data *tdata)
+test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct aead_test_data tdata;
+	int res;
 
-	int retval;
-	uint8_t *ciphertext, *auth_tag;
-	uint16_t plaintext_pad_len;
-	uint32_t i;
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.iv.data[0] += 1;
+	res = test_authenticated_decryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
+	return TEST_SUCCESS;
+}
 
-	/* Create AEAD session */
-	retval = create_aead_session(ts_params->valid_devs[0],
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_ENCRYPT,
-			tdata->key.data, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
+static int
+test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
+{
+	struct aead_test_data tdata;
+	int res;
 
-	if (tdata->aad.len > MBUF_SIZE) {
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
-		/* Populate full size of add data */
-		for (i = 32; i < MAX_AAD_LENGTH; i += 32)
-			memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
-	} else
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.plaintext.data[0] += 1;
+	res = test_authenticated_decryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
+	return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
+{
+	struct aead_test_data tdata;
+	int res;
+
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.ciphertext.data[0] += 1;
+	res = test_authenticated_decryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
+	return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
+{
+	struct aead_test_data tdata;
+	int res;
+
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.aad.len += 1;
+	res = test_authenticated_decryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
+	return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
+{
+	struct aead_test_data tdata;
+	uint8_t aad[gcm_test_case_7.aad.len];
+	int res;
+
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
+	aad[0] += 1;
+	tdata.aad.data = aad;
+	res = test_authenticated_decryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
+	return TEST_SUCCESS;
+}
+
+static int
+test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
+{
+	struct aead_test_data tdata;
+	int res;
+
+	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
+	tdata.auth_tag.data[0] += 1;
+	res = test_authenticated_decryption(&tdata);
+	if (res == -ENOTSUP)
+		return res;
+	TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
+	return TEST_SUCCESS;
+}
+
+static int
+test_authenticated_encryption_oop(const struct aead_test_data *tdata)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+
+	int retval;
+	uint8_t *ciphertext, *auth_tag;
+	uint16_t plaintext_pad_len;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create AEAD session */
+	retval = create_aead_session(ts_params->valid_devs[0],
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_ENCRYPT,
+			tdata->key.data, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
+	if (retval < 0)
+		return retval;
+
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
 	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 			rte_pktmbuf_tailroom(ut_params->ibuf));
+	memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->obuf));
 
 	/* Create AEAD operation */
 	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
@@ -7851,6 +8222,7 @@  test_authenticated_encryption(const struct aead_test_data *tdata)
 	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
 	ut_params->op->sym->m_src = ut_params->ibuf;
+	ut_params->op->sym->m_dst = ut_params->obuf;
 
 	/* Process crypto operation */
 	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
@@ -7861,17 +8233,9 @@  test_authenticated_encryption(const struct aead_test_data *tdata)
 
 	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
 
-	if (ut_params->op->sym->m_dst) {
-		ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
-				uint8_t *);
-		auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
-				uint8_t *, plaintext_pad_len);
-	} else {
-		ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
-				uint8_t *,
-				ut_params->op->sym->cipher.data.offset);
-		auth_tag = ciphertext + plaintext_pad_len;
-	}
+	ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+			ut_params->op->sym->cipher.data.offset);
+	auth_tag = ciphertext + plaintext_pad_len;
 
 	debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
 	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
@@ -7893,1713 +8257,1390 @@  test_authenticated_encryption(const struct aead_test_data *tdata)
 
 }
 
-#ifdef RTE_LIBRTE_SECURITY
-/* Basic algorithm run function for async inplace mode.
- * Creates a session from input parameters and runs one operation
- * on input_vec. Checks the output of the crypto operation against
- * output_vec.
- */
 static int
-test_pdcp_proto(int i, int oop,
-	enum rte_crypto_cipher_operation opc,
-	enum rte_crypto_auth_operation opa,
-	uint8_t *input_vec,
-	unsigned int input_vec_len,
-	uint8_t *output_vec,
-	unsigned int output_vec_len)
+test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
+{
+	return test_authenticated_encryption_oop(&gcm_test_case_5);
+}
+
+static int
+test_authenticated_decryption_oop(const struct aead_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+
+	int retval;
 	uint8_t *plaintext;
-	int ret = TEST_SUCCESS;
 
-	/* Generate test mbuf data */
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create AEAD session */
+	retval = create_aead_session(ts_params->valid_devs[0],
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_DECRYPT,
+			tdata->key.data, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
+	if (retval < 0)
+		return retval;
+
+	/* alloc mbuf and set payload */
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 			rte_pktmbuf_tailroom(ut_params->ibuf));
+	memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->obuf));
 
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-						  input_vec_len);
-	memcpy(plaintext, input_vec, input_vec_len);
+	/* Create AEAD operation */
+	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
+	if (retval < 0)
+		return retval;
 
-	/* Out of place support */
-	if (oop) {
-		/*
-		 * For out-op-place we need to alloc another mbuf
-		 */
-		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-		rte_pktmbuf_append(ut_params->obuf, output_vec_len);
-	}
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	/* Set crypto type as IPSEC */
-	ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+	ut_params->op->sym->m_src = ut_params->ibuf;
+	ut_params->op->sym->m_dst = ut_params->obuf;
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
-	ut_params->cipher_xform.cipher.op = opc;
-	ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
-	ut_params->cipher_xform.cipher.key.length =
-					pdcp_test_params[i].cipher_key_len;
-	ut_params->cipher_xform.cipher.iv.length = 0;
+	/* Process crypto operation */
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
-	/* Setup HMAC Parameters if ICV header is required */
-	if (pdcp_test_params[i].auth_alg != 0) {
-		ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-		ut_params->auth_xform.next = NULL;
-		ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
-		ut_params->auth_xform.auth.op = opa;
-		ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
-		ut_params->auth_xform.auth.key.length =
-					pdcp_test_params[i].auth_key_len;
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
 
-		ut_params->cipher_xform.next = &ut_params->auth_xform;
-	} else {
-		ut_params->cipher_xform.next = NULL;
-	}
+	plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+			ut_params->op->sym->cipher.data.offset);
 
-	struct rte_security_session_conf sess_conf = {
-		.action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
-		.protocol = RTE_SECURITY_PROTOCOL_PDCP,
-		{.pdcp = {
-			.bearer = pdcp_test_bearer[i],
-			.domain = pdcp_test_params[i].domain,
-			.pkt_dir = pdcp_test_packet_direction[i],
-			.sn_size = pdcp_test_data_sn_size[i],
-			.hfn = pdcp_test_hfn[i],
-			.hfn_threshold = pdcp_test_hfn_threshold[i],
-		} },
-		.crypto_xform = &ut_params->cipher_xform
-	};
+	debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
 
-	struct rte_security_ctx *ctx = (struct rte_security_ctx *)
-				rte_cryptodev_get_sec_ctx(
-				ts_params->valid_devs[0]);
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len,
+			"Plaintext data not as expected");
 
-	/* Create security session */
-	ut_params->sec_session = rte_security_session_create(ctx,
-				&sess_conf, ts_params->session_priv_mpool);
+	TEST_ASSERT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"Authentication failed");
+	return 0;
+}
 
-	if (!ut_params->sec_session) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__, "Failed to allocate session");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
+static int
+test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
+{
+	return test_authenticated_decryption_oop(&gcm_test_case_5);
+}
 
-	/* Generate crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	if (!ut_params->op) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__,
-			"Failed to allocate symmetric crypto operation struct");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
+static int
+test_authenticated_encryption_sessionless(
+		const struct aead_test_data *tdata)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	rte_security_attach_session(ut_params->op, ut_params->sec_session);
+	int retval;
+	uint8_t *ciphertext, *auth_tag;
+	uint16_t plaintext_pad_len;
+	uint8_t key[tdata->key.len + 1];
+
+	/* This test is for AESNI MB and AESNI GCM PMDs only */
+	if ((gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) &&
+			(gbl_driver_id != rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))))
+		return -ENOTSUP;
+
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
+
+	/* Create AEAD operation */
+	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
+	if (retval < 0)
+		return retval;
+
+	/* Create GCM xform */
+	memcpy(key, tdata->key.data, tdata->key.len);
+	retval = create_aead_xform(ut_params->op,
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_ENCRYPT,
+			key, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
+	if (retval < 0)
+		return retval;
 
-	/* set crypto operation source mbuf */
 	ut_params->op->sym->m_src = ut_params->ibuf;
-	if (oop)
-		ut_params->op->sym->m_dst = ut_params->obuf;
+
+	TEST_ASSERT_EQUAL(ut_params->op->sess_type,
+			RTE_CRYPTO_OP_SESSIONLESS,
+			"crypto op session type not sessionless");
 
 	/* Process crypto operation */
-	if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
-		== NULL) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__,
-			"failed to process sym crypto op");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
-	if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__, "crypto op processing failed");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
 
-	/* Validate obuf */
-	uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
-			uint8_t *);
-	if (oop) {
-		ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
-				uint8_t *);
-	}
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op status not success");
 
-	if (memcmp(ciphertext, output_vec, output_vec_len)) {
-		printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
-		rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
-		rte_hexdump(stdout, "reference", output_vec, output_vec_len);
-		ret = TEST_FAILED;
-		goto on_err;
-	}
+	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
 
-on_err:
-	rte_crypto_op_free(ut_params->op);
-	ut_params->op = NULL;
+	ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			ut_params->op->sym->cipher.data.offset);
+	auth_tag = ciphertext + plaintext_pad_len;
 
-	if (ut_params->sec_session)
-		rte_security_session_destroy(ctx, ut_params->sec_session);
-	ut_params->sec_session = NULL;
+	debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
+	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
 
-	rte_pktmbuf_free(ut_params->ibuf);
-	ut_params->ibuf = NULL;
-	if (oop) {
-		rte_pktmbuf_free(ut_params->obuf);
-		ut_params->obuf = NULL;
-	}
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			ciphertext,
+			tdata->ciphertext.data,
+			tdata->ciphertext.len,
+			"Ciphertext data not as expected");
+
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			auth_tag,
+			tdata->auth_tag.data,
+			tdata->auth_tag.len,
+			"Generated auth tag not as expected");
+
+	return 0;
 
-	return ret;
 }
 
 static int
-test_pdcp_proto_SGL(int i, int oop,
-	enum rte_crypto_cipher_operation opc,
-	enum rte_crypto_auth_operation opa,
-	uint8_t *input_vec,
-	unsigned int input_vec_len,
-	uint8_t *output_vec,
-	unsigned int output_vec_len,
-	uint32_t fragsz,
-	uint32_t fragsz_oop)
+test_AES_GCM_auth_encryption_sessionless_test_case_1(void)
+{
+	return test_authenticated_encryption_sessionless(
+			&gcm_test_case_5);
+}
+
+static int
+test_authenticated_decryption_sessionless(
+		const struct aead_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
-	uint8_t *plaintext;
-	struct rte_mbuf *buf, *buf_oop = NULL;
-	int ret = TEST_SUCCESS;
-	int to_trn = 0;
-	int to_trn_tbl[16];
-	int segs = 1;
-	unsigned int trn_data = 0;
-
-	if (fragsz > input_vec_len)
-		fragsz = input_vec_len;
 
-	uint16_t plaintext_len = fragsz;
-	uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
-
-	if (fragsz_oop > output_vec_len)
-		frag_size_oop = output_vec_len;
+	int retval;
+	uint8_t *plaintext;
+	uint8_t key[tdata->key.len + 1];
 
-	int ecx = 0;
-	if (input_vec_len % fragsz != 0) {
-		if (input_vec_len / fragsz + 1 > 16)
-			return 1;
-	} else if (input_vec_len / fragsz > 16)
-		return 1;
+	/* This test is for AESNI MB and AESNI GCM PMDs only */
+	if ((gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) &&
+			(gbl_driver_id != rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))))
+		return -ENOTSUP;
 
-	/* Out of place support */
-	if (oop) {
-		/*
-		 * For out-op-place we need to alloc another mbuf
-		 */
-		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-		rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
-		buf_oop = ut_params->obuf;
-	}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* Generate test mbuf data */
+	/* alloc mbuf and set payload */
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-						  plaintext_len);
-	memcpy(plaintext, input_vec, plaintext_len);
-	trn_data += plaintext_len;
-
-	buf = ut_params->ibuf;
+	/* Create AEAD operation */
+	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
+	if (retval < 0)
+		return retval;
 
-	/*
-	 * Loop until no more fragments
-	 */
+	/* Create AEAD xform */
+	memcpy(key, tdata->key.data, tdata->key.len);
+	retval = create_aead_xform(ut_params->op,
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_DECRYPT,
+			key, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
+	if (retval < 0)
+		return retval;
 
-	while (trn_data < input_vec_len) {
-		++segs;
-		to_trn = (input_vec_len - trn_data < fragsz) ?
-				(input_vec_len - trn_data) : fragsz;
+	ut_params->op->sym->m_src = ut_params->ibuf;
 
-		to_trn_tbl[ecx++] = to_trn;
+	TEST_ASSERT_EQUAL(ut_params->op->sess_type,
+			RTE_CRYPTO_OP_SESSIONLESS,
+			"crypto op session type not sessionless");
 
-		buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-		buf = buf->next;
+	/* Process crypto operation */
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
-		memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
-				rte_pktmbuf_tailroom(buf));
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
 
-		/* OOP */
-		if (oop && !fragsz_oop) {
-			buf_oop->next =
-					rte_pktmbuf_alloc(ts_params->mbuf_pool);
-			buf_oop = buf_oop->next;
-			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
-					0, rte_pktmbuf_tailroom(buf_oop));
-			rte_pktmbuf_append(buf_oop, to_trn);
-		}
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op status not success");
 
-		plaintext = (uint8_t *)rte_pktmbuf_append(buf,
-				to_trn);
+	plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			ut_params->op->sym->cipher.data.offset);
 
-		memcpy(plaintext, input_vec + trn_data, to_trn);
-		trn_data += to_trn;
-	}
+	debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
 
-	ut_params->ibuf->nb_segs = segs;
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			plaintext,
+			tdata->plaintext.data,
+			tdata->plaintext.len,
+			"Plaintext data not as expected");
 
-	segs = 1;
-	if (fragsz_oop && oop) {
-		to_trn = 0;
-		ecx = 0;
+	TEST_ASSERT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"Authentication failed");
+	return 0;
+}
 
-		trn_data = frag_size_oop;
-		while (trn_data < output_vec_len) {
-			++segs;
-			to_trn =
-				(output_vec_len - trn_data <
-						frag_size_oop) ?
-				(output_vec_len - trn_data) :
-						frag_size_oop;
+static int
+test_AES_GCM_auth_decryption_sessionless_test_case_1(void)
+{
+	return test_authenticated_decryption_sessionless(
+			&gcm_test_case_5);
+}
 
-			to_trn_tbl[ecx++] = to_trn;
+static int
+test_AES_CCM_authenticated_encryption_test_case_128_1(void)
+{
+	return test_authenticated_encryption(&ccm_test_case_128_1);
+}
 
-			buf_oop->next =
-				rte_pktmbuf_alloc(ts_params->mbuf_pool);
-			buf_oop = buf_oop->next;
-			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
-					0, rte_pktmbuf_tailroom(buf_oop));
-			rte_pktmbuf_append(buf_oop, to_trn);
-
-			trn_data += to_trn;
-		}
-		ut_params->obuf->nb_segs = segs;
-	}
-
-	ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
-
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
-	ut_params->cipher_xform.cipher.op = opc;
-	ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
-	ut_params->cipher_xform.cipher.key.length =
-					pdcp_test_params[i].cipher_key_len;
-	ut_params->cipher_xform.cipher.iv.length = 0;
-
-	/* Setup HMAC Parameters if ICV header is required */
-	if (pdcp_test_params[i].auth_alg != 0) {
-		ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-		ut_params->auth_xform.next = NULL;
-		ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
-		ut_params->auth_xform.auth.op = opa;
-		ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
-		ut_params->auth_xform.auth.key.length =
-					pdcp_test_params[i].auth_key_len;
-
-		ut_params->cipher_xform.next = &ut_params->auth_xform;
-	} else {
-		ut_params->cipher_xform.next = NULL;
-	}
-
-	struct rte_security_session_conf sess_conf = {
-		.action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
-		.protocol = RTE_SECURITY_PROTOCOL_PDCP,
-		{.pdcp = {
-			.bearer = pdcp_test_bearer[i],
-			.domain = pdcp_test_params[i].domain,
-			.pkt_dir = pdcp_test_packet_direction[i],
-			.sn_size = pdcp_test_data_sn_size[i],
-			.hfn = pdcp_test_hfn[i],
-			.hfn_threshold = pdcp_test_hfn_threshold[i],
-		} },
-		.crypto_xform = &ut_params->cipher_xform
-	};
-
-	struct rte_security_ctx *ctx = (struct rte_security_ctx *)
-				rte_cryptodev_get_sec_ctx(
-				ts_params->valid_devs[0]);
-
-	/* Create security session */
-	ut_params->sec_session = rte_security_session_create(ctx,
-				&sess_conf, ts_params->session_priv_mpool);
-
-	if (!ut_params->sec_session) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__, "Failed to allocate session");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
-
-	/* Generate crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	if (!ut_params->op) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__,
-			"Failed to allocate symmetric crypto operation struct");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
-
-	rte_security_attach_session(ut_params->op, ut_params->sec_session);
-
-	/* set crypto operation source mbuf */
-	ut_params->op->sym->m_src = ut_params->ibuf;
-	if (oop)
-		ut_params->op->sym->m_dst = ut_params->obuf;
-
-	/* Process crypto operation */
-	if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
-		== NULL) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__,
-			"failed to process sym crypto op");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
-
-	if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
-		printf("TestCase %s()-%d line %d failed %s: ",
-			__func__, i, __LINE__, "crypto op processing failed");
-		ret = TEST_FAILED;
-		goto on_err;
-	}
-
-	/* Validate obuf */
-	uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
-			uint8_t *);
-	if (oop) {
-		ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
-				uint8_t *);
-	}
-	if (fragsz_oop)
-		fragsz = frag_size_oop;
-	if (memcmp(ciphertext, output_vec, fragsz)) {
-		printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
-		rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
-		rte_hexdump(stdout, "reference", output_vec, fragsz);
-		ret = TEST_FAILED;
-		goto on_err;
-	}
-
-	buf = ut_params->op->sym->m_src->next;
-	if (oop)
-		buf = ut_params->op->sym->m_dst->next;
+static int
+test_AES_CCM_authenticated_encryption_test_case_128_2(void)
+{
+	return test_authenticated_encryption(&ccm_test_case_128_2);
+}
 
-	unsigned int off = fragsz;
+static int
+test_AES_CCM_authenticated_encryption_test_case_128_3(void)
+{
+	return test_authenticated_encryption(&ccm_test_case_128_3);
+}
 
-	ecx = 0;
-	while (buf) {
-		ciphertext = rte_pktmbuf_mtod(buf,
-				uint8_t *);
-		if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
-			printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
-			rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
-			rte_hexdump(stdout, "reference", output_vec + off,
-					to_trn_tbl[ecx]);
-			ret = TEST_FAILED;
-			goto on_err;
-		}
-		off += to_trn_tbl[ecx++];
-		buf = buf->next;
-	}
-on_err:
-	rte_crypto_op_free(ut_params->op);
-	ut_params->op = NULL;
+static int
+test_AES_CCM_authenticated_decryption_test_case_128_1(void)
+{
+	return test_authenticated_decryption(&ccm_test_case_128_1);
+}
 
-	if (ut_params->sec_session)
-		rte_security_session_destroy(ctx, ut_params->sec_session);
-	ut_params->sec_session = NULL;
+static int
+test_AES_CCM_authenticated_decryption_test_case_128_2(void)
+{
+	return test_authenticated_decryption(&ccm_test_case_128_2);
+}
 
-	rte_pktmbuf_free(ut_params->ibuf);
-	ut_params->ibuf = NULL;
-	if (oop) {
-		rte_pktmbuf_free(ut_params->obuf);
-		ut_params->obuf = NULL;
-	}
+static int
+test_AES_CCM_authenticated_decryption_test_case_128_3(void)
+{
+	return test_authenticated_decryption(&ccm_test_case_128_3);
+}
 
-	return ret;
+static int
+test_AES_CCM_authenticated_encryption_test_case_192_1(void)
+{
+	return test_authenticated_encryption(&ccm_test_case_192_1);
 }
 
-int
-test_pdcp_proto_cplane_encap(int i)
+static int
+test_AES_CCM_authenticated_encryption_test_case_192_2(void)
 {
-	return test_pdcp_proto(i, 0,
-		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-		RTE_CRYPTO_AUTH_OP_GENERATE,
-		pdcp_test_data_in[i],
-		pdcp_test_data_in_len[i],
-		pdcp_test_data_out[i],
-		pdcp_test_data_in_len[i]+4);
+	return test_authenticated_encryption(&ccm_test_case_192_2);
 }
 
-int
-test_pdcp_proto_uplane_encap(int i)
+static int
+test_AES_CCM_authenticated_encryption_test_case_192_3(void)
 {
-	return test_pdcp_proto(i, 0,
-		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-		RTE_CRYPTO_AUTH_OP_GENERATE,
-		pdcp_test_data_in[i],
-		pdcp_test_data_in_len[i],
-		pdcp_test_data_out[i],
-		pdcp_test_data_in_len[i]);
+	return test_authenticated_encryption(&ccm_test_case_192_3);
+}
 
+static int
+test_AES_CCM_authenticated_decryption_test_case_192_1(void)
+{
+	return test_authenticated_decryption(&ccm_test_case_192_1);
 }
 
-int
-test_pdcp_proto_uplane_encap_with_int(int i)
+static int
+test_AES_CCM_authenticated_decryption_test_case_192_2(void)
 {
-	return test_pdcp_proto(i, 0,
-		RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-		RTE_CRYPTO_AUTH_OP_GENERATE,
-		pdcp_test_data_in[i],
-		pdcp_test_data_in_len[i],
-		pdcp_test_data_out[i],
-		pdcp_test_data_in_len[i] + 4);
+	return test_authenticated_decryption(&ccm_test_case_192_2);
 }
 
-int
-test_pdcp_proto_cplane_decap(int i)
+static int
+test_AES_CCM_authenticated_decryption_test_case_192_3(void)
 {
-	return test_pdcp_proto(i, 0,
-		RTE_CRYPTO_CIPHER_OP_DECRYPT,
-		RTE_CRYPTO_AUTH_OP_VERIFY,
-		pdcp_test_data_out[i],
-		pdcp_test_data_in_len[i] + 4,
-		pdcp_test_data_in[i],
-		pdcp_test_data_in_len[i]);
+	return test_authenticated_decryption(&ccm_test_case_192_3);
 }
 
-int
-test_pdcp_proto_uplane_decap(int i)
+static int
+test_AES_CCM_authenticated_encryption_test_case_256_1(void)
 {
-	return test_pdcp_proto(i, 0,
-		RTE_CRYPTO_CIPHER_OP_DECRYPT,
-		RTE_CRYPTO_AUTH_OP_VERIFY,
-		pdcp_test_data_out[i],
-		pdcp_test_data_in_len[i],
-		pdcp_test_data_in[i],
-		pdcp_test_data_in_len[i]);
+	return test_authenticated_encryption(&ccm_test_case_256_1);
 }
 
-int
-test_pdcp_proto_uplane_decap_with_int(int i)
+static int
+test_AES_CCM_authenticated_encryption_test_case_256_2(void)
 {
-	return test_pdcp_proto(i, 0,
-		RTE_CRYPTO_CIPHER_OP_DECRYPT,
-		RTE_CRYPTO_AUTH_OP_VERIFY,
-		pdcp_test_data_out[i],
-		pdcp_test_data_in_len[i] + 4,
-		pdcp_test_data_in[i],
-		pdcp_test_data_in_len[i]);
+	return test_authenticated_encryption(&ccm_test_case_256_2);
 }
 
 static int
-test_PDCP_PROTO_SGL_in_place_32B(void)
+test_AES_CCM_authenticated_encryption_test_case_256_3(void)
 {
-	/* i can be used for running any PDCP case
-	 * In this case it is uplane 12-bit AES-SNOW DL encap
-	 */
-	int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
-	return test_pdcp_proto_SGL(i, IN_PLACE,
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			pdcp_test_data_in[i],
-			pdcp_test_data_in_len[i],
-			pdcp_test_data_out[i],
-			pdcp_test_data_in_len[i]+4,
-			32, 0);
-}
-static int
-test_PDCP_PROTO_SGL_oop_32B_128B(void)
-{
-	/* i can be used for running any PDCP case
-	 * In this case it is uplane 18-bit NULL-NULL DL encap
-	 */
-	int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
-	return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			pdcp_test_data_in[i],
-			pdcp_test_data_in_len[i],
-			pdcp_test_data_out[i],
-			pdcp_test_data_in_len[i]+4,
-			32, 128);
-}
-static int
-test_PDCP_PROTO_SGL_oop_32B_40B(void)
-{
-	/* i can be used for running any PDCP case
-	 * In this case it is uplane 18-bit AES DL encap
-	 */
-	int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
-			+ DOWNLINK;
-	return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			pdcp_test_data_in[i],
-			pdcp_test_data_in_len[i],
-			pdcp_test_data_out[i],
-			pdcp_test_data_in_len[i],
-			32, 40);
-}
-static int
-test_PDCP_PROTO_SGL_oop_128B_32B(void)
-{
-	/* i can be used for running any PDCP case
-	 * In this case it is cplane 12-bit AES-ZUC DL encap
-	 */
-	int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
-	return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
-			RTE_CRYPTO_CIPHER_OP_ENCRYPT,
-			RTE_CRYPTO_AUTH_OP_GENERATE,
-			pdcp_test_data_in[i],
-			pdcp_test_data_in_len[i],
-			pdcp_test_data_out[i],
-			pdcp_test_data_in_len[i]+4,
-			128, 32);
+	return test_authenticated_encryption(&ccm_test_case_256_3);
 }
-#endif
 
 static int
-test_AES_GCM_authenticated_encryption_test_case_1(void)
+test_AES_CCM_authenticated_decryption_test_case_256_1(void)
 {
-	return test_authenticated_encryption(&gcm_test_case_1);
+	return test_authenticated_decryption(&ccm_test_case_256_1);
 }
 
 static int
-test_AES_GCM_authenticated_encryption_test_case_2(void)
+test_AES_CCM_authenticated_decryption_test_case_256_2(void)
 {
-	return test_authenticated_encryption(&gcm_test_case_2);
+	return test_authenticated_decryption(&ccm_test_case_256_2);
 }
 
 static int
-test_AES_GCM_authenticated_encryption_test_case_3(void)
+test_AES_CCM_authenticated_decryption_test_case_256_3(void)
 {
-	return test_authenticated_encryption(&gcm_test_case_3);
+	return test_authenticated_decryption(&ccm_test_case_256_3);
 }
 
 static int
-test_AES_GCM_authenticated_encryption_test_case_4(void)
+test_stats(void)
 {
-	return test_authenticated_encryption(&gcm_test_case_4);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct rte_cryptodev_stats stats;
+	struct rte_cryptodev *dev;
+	cryptodev_stats_get_t temp_pfn;
 
-static int
-test_AES_GCM_authenticated_encryption_test_case_5(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_5);
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_AES_GCM_authenticated_encryption_test_case_6(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_6);
-}
+	rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 
-static int
-test_AES_GCM_authenticated_encryption_test_case_7(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_7);
-}
+	TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
+			&stats) == -ENODEV),
+		"rte_cryptodev_stats_get invalid dev failed");
+	TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
+		"rte_cryptodev_stats_get invalid Param failed");
+	dev = &rte_cryptodevs[ts_params->valid_devs[0]];
+	temp_pfn = dev->dev_ops->stats_get;
+	dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
+	TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
+			== -ENOTSUP),
+		"rte_cryptodev_stats_get invalid Param failed");
+	dev->dev_ops->stats_get = temp_pfn;
 
-static int
-test_AES_GCM_authenticated_encryption_test_case_8(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_8);
-}
+	/* Test expected values */
+	ut_setup();
+	test_AES_CBC_HMAC_SHA1_encrypt_digest();
+	ut_teardown();
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_1(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_1);
-}
+	TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
+			&stats),
+		"rte_cryptodev_stats_get failed");
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_2(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_2);
-}
+	TEST_ASSERT((stats.enqueued_count == 1),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	TEST_ASSERT((stats.dequeued_count == 1),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	TEST_ASSERT((stats.enqueue_err_count == 0),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	TEST_ASSERT((stats.dequeue_err_count == 0),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_3(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_3);
-}
+	/* invalid device but should ignore and not reset device stats*/
+	rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
+	TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
+			&stats),
+		"rte_cryptodev_stats_get failed");
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_4(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_4);
-}
+	TEST_ASSERT((stats.enqueued_count == 1),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_5(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_5);
-}
+	/* check that a valid reset clears stats */
+	rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
+	TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
+			&stats),
+					  "rte_cryptodev_stats_get failed");
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_6(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_6);
-}
+	TEST_ASSERT((stats.enqueued_count == 0),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	TEST_ASSERT((stats.dequeued_count == 0),
+		"rte_cryptodev_stats_get returned unexpected enqueued stat");
 
-static int
-test_AES_GCM_auth_encryption_test_case_192_7(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_192_7);
+	return TEST_SUCCESS;
 }
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_1(void)
+static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
+				   struct crypto_unittest_params *ut_params,
+				   enum rte_crypto_auth_operation op,
+				   const struct HMAC_MD5_vector *test_case)
 {
-	return test_authenticated_encryption(&gcm_test_case_256_1);
-}
+	uint8_t key[64];
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_2(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_256_2);
-}
+	memcpy(key, test_case->key.data, test_case->key.len);
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_3(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_256_3);
-}
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
+	ut_params->auth_xform.auth.op = op;
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_4(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_256_4);
-}
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_5(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_256_5);
-}
+	ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
+	ut_params->auth_xform.auth.key.length = test_case->key.len;
+	ut_params->auth_xform.auth.key.data = key;
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_6(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_256_6);
-}
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-static int
-test_AES_GCM_auth_encryption_test_case_256_7(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_256_7);
-}
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			ut_params->sess, &ut_params->auth_xform,
+			ts_params->session_priv_mpool);
 
-static int
-test_AES_GCM_auth_encryption_test_case_aad_1(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_aad_1);
-}
+	if (ut_params->sess == NULL)
+		return TEST_FAILED;
 
-static int
-test_AES_GCM_auth_encryption_test_case_aad_2(void)
-{
-	return test_authenticated_encryption(&gcm_test_case_aad_2);
-}
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-static int
-test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.iv.data[0] += 1;
-	res = test_authenticated_encryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
-	return TEST_SUCCESS;
+	return 0;
 }
 
-static int
-test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
+static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
+			      const struct HMAC_MD5_vector *test_case,
+			      uint8_t **plaintext)
 {
-	struct aead_test_data tdata;
-	int res;
-
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.plaintext.data[0] += 1;
-	res = test_authenticated_encryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
-	return TEST_SUCCESS;
-}
+	uint16_t plaintext_pad_len;
 
-static int
-test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.ciphertext.data[0] += 1;
-	res = test_authenticated_encryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
-	return TEST_SUCCESS;
-}
+	plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
+				16);
 
-static int
-test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	*plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+			plaintext_pad_len);
+	memcpy(*plaintext, test_case->plaintext.data,
+			test_case->plaintext.len);
 
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.aad.len += 1;
-	res = test_authenticated_encryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
-	return TEST_SUCCESS;
-}
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+			ut_params->ibuf, MD5_DIGEST_LEN);
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+			"no room to append digest");
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			ut_params->ibuf, plaintext_pad_len);
 
-static int
-test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
-{
-	struct aead_test_data tdata;
-	uint8_t aad[gcm_test_case_7.aad.len];
-	int res;
+	if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
+		rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
+			   test_case->auth_tag.len);
+	}
 
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
-	aad[0] += 1;
-	tdata.aad.data = aad;
-	res = test_authenticated_encryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
-	return TEST_SUCCESS;
-}
+	sym_op->auth.data.offset = 0;
+	sym_op->auth.data.length = test_case->plaintext.len;
 
-static int
-test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	ut_params->op->sym->m_src = ut_params->ibuf;
 
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.auth_tag.data[0] += 1;
-	res = test_authenticated_encryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
-	return TEST_SUCCESS;
+	return 0;
 }
 
 static int
-test_authenticated_decryption(const struct aead_test_data *tdata)
+test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
 {
+	uint16_t plaintext_pad_len;
+	uint8_t *plaintext, *auth_tag;
+
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	int retval;
-	uint8_t *plaintext;
-	uint32_t i;
-
-	/* Create AEAD session */
-	retval = create_aead_session(ts_params->valid_devs[0],
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_DECRYPT,
-			tdata->key.data, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
-
-	/* alloc mbuf and set payload */
-	if (tdata->aad.len > MBUF_SIZE) {
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
-		/* Populate full size of add data */
-		for (i = 32; i < MAX_AAD_LENGTH; i += 32)
-			memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
-	} else
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+	if (MD5_HMAC_create_session(ts_params, ut_params,
+			RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
+		return TEST_FAILED;
 
-	/* Create AEAD operation */
-	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
-	if (retval < 0)
-		return retval;
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
+				16);
 
-	ut_params->op->sym->m_src = ut_params->ibuf;
+	if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
+		return TEST_FAILED;
 
-	/* Process crypto operation */
 	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op), "failed to process sym crypto op");
 
 	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
 			"crypto op processing failed");
 
-	if (ut_params->op->sym->m_dst)
-		plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
-				uint8_t *);
-	else
-		plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
-				uint8_t *,
-				ut_params->op->sym->cipher.data.offset);
-
-	debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+	if (ut_params->op->sym->m_dst) {
+		auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
+				uint8_t *, plaintext_pad_len);
+	} else {
+		auth_tag = plaintext + plaintext_pad_len;
+	}
 
-	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len,
-			"Plaintext data not as expected");
-
-	TEST_ASSERT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"Authentication failed");
+			auth_tag,
+			test_case->auth_tag.data,
+			test_case->auth_tag.len,
+			"HMAC_MD5 generated tag not as expected");
 
-	return 0;
+	return TEST_SUCCESS;
 }
 
 static int
-test_AES_GCM_authenticated_decryption_test_case_1(void)
+test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
 {
-	return test_authenticated_decryption(&gcm_test_case_1);
-}
+	uint8_t *plaintext;
 
-static int
-test_AES_GCM_authenticated_decryption_test_case_2(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_2);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-static int
-test_AES_GCM_authenticated_decryption_test_case_3(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_3);
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_AES_GCM_authenticated_decryption_test_case_4(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_4);
-}
+	if (MD5_HMAC_create_session(ts_params, ut_params,
+			RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
+		return TEST_FAILED;
+	}
 
-static int
-test_AES_GCM_authenticated_decryption_test_case_5(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_5);
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
-static int
-test_AES_GCM_authenticated_decryption_test_case_6(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_6);
+	if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
+		return TEST_FAILED;
+
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
+
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"HMAC_MD5 crypto op processing failed");
+
+	return TEST_SUCCESS;
 }
 
 static int
-test_AES_GCM_authenticated_decryption_test_case_7(void)
+test_MD5_HMAC_generate_case_1(void)
 {
-	return test_authenticated_decryption(&gcm_test_case_7);
+	return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
 }
 
 static int
-test_AES_GCM_authenticated_decryption_test_case_8(void)
+test_MD5_HMAC_verify_case_1(void)
 {
-	return test_authenticated_decryption(&gcm_test_case_8);
+	return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
 }
 
 static int
-test_AES_GCM_auth_decryption_test_case_192_1(void)
+test_MD5_HMAC_generate_case_2(void)
 {
-	return test_authenticated_decryption(&gcm_test_case_192_1);
+	return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
 }
 
 static int
-test_AES_GCM_auth_decryption_test_case_192_2(void)
+test_MD5_HMAC_verify_case_2(void)
 {
-	return test_authenticated_decryption(&gcm_test_case_192_2);
+	return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
 }
 
 static int
-test_AES_GCM_auth_decryption_test_case_192_3(void)
+test_multi_session(void)
 {
-	return test_authenticated_decryption(&gcm_test_case_192_3);
-}
-
-static int
-test_AES_GCM_auth_decryption_test_case_192_4(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_192_4);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-static int
-test_AES_GCM_auth_decryption_test_case_192_5(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_192_5);
-}
+	struct rte_cryptodev_info dev_info;
+	struct rte_cryptodev_sym_session **sessions;
 
-static int
-test_AES_GCM_auth_decryption_test_case_192_6(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_192_6);
-}
+	uint16_t i;
 
-static int
-test_AES_GCM_auth_decryption_test_case_192_7(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_192_7);
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_1(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_1);
-}
+	test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
+			aes_cbc_key, hmac_sha512_key);
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_2(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_2);
-}
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_3(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_3);
-}
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_4(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_4);
-}
+	sessions = rte_malloc(NULL,
+			(sizeof(struct rte_cryptodev_sym_session *) *
+			MAX_NB_SESSIONS) + 1, 0);
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_5(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_5);
-}
+	/* Create multiple crypto sessions*/
+	for (i = 0; i < MAX_NB_SESSIONS; i++) {
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_6(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_6);
-}
+		sessions[i] = rte_cryptodev_sym_session_create(
+				ts_params->session_mpool);
 
-static int
-test_AES_GCM_auth_decryption_test_case_256_7(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_256_7);
-}
+		rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+				sessions[i], &ut_params->auth_xform,
+				ts_params->session_priv_mpool);
+		TEST_ASSERT_NOT_NULL(sessions[i],
+				"Session creation failed at session number %u",
+				i);
 
-static int
-test_AES_GCM_auth_decryption_test_case_aad_1(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_aad_1);
-}
+		/* Attempt to send a request on each session */
+		TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
+			sessions[i],
+			ut_params,
+			ts_params,
+			catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
+			catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
+			aes_cbc_iv),
+			"Failed to perform decrypt on request number %u.", i);
+		/* free crypto operation structure */
+		if (ut_params->op)
+			rte_crypto_op_free(ut_params->op);
 
-static int
-test_AES_GCM_auth_decryption_test_case_aad_2(void)
-{
-	return test_authenticated_decryption(&gcm_test_case_aad_2);
-}
+		/*
+		 * free mbuf - both obuf and ibuf are usually the same,
+		 * so check if they point at the same address is necessary,
+		 * to avoid freeing the mbuf twice.
+		 */
+		if (ut_params->obuf) {
+			rte_pktmbuf_free(ut_params->obuf);
+			if (ut_params->ibuf == ut_params->obuf)
+				ut_params->ibuf = 0;
+			ut_params->obuf = 0;
+		}
+		if (ut_params->ibuf) {
+			rte_pktmbuf_free(ut_params->ibuf);
+			ut_params->ibuf = 0;
+		}
+	}
 
-static int
-test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	/* Next session create should fail */
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			sessions[i], &ut_params->auth_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_NULL(sessions[i],
+			"Session creation succeeded unexpectedly!");
 
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.iv.data[0] += 1;
-	res = test_authenticated_decryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
-	return TEST_SUCCESS;
-}
+	for (i = 0; i < MAX_NB_SESSIONS; i++) {
+		rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
+				sessions[i]);
+		rte_cryptodev_sym_session_free(sessions[i]);
+	}
 
-static int
-test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	rte_free(sessions);
 
-	RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.plaintext.data[0] += 1;
-	res = test_authenticated_decryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
 	return TEST_SUCCESS;
 }
 
-static int
-test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+struct multi_session_params {
+	struct crypto_unittest_params ut_params;
+	uint8_t *cipher_key;
+	uint8_t *hmac_key;
+	const uint8_t *cipher;
+	const uint8_t *digest;
+	uint8_t *iv;
+};
 
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.ciphertext.data[0] += 1;
-	res = test_authenticated_decryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
-	return TEST_SUCCESS;
-}
+#define MB_SESSION_NUMBER 3
 
 static int
-test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
+test_multi_session_random_usage(void)
 {
-	struct aead_test_data tdata;
-	int res;
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct rte_cryptodev_info dev_info;
+	struct rte_cryptodev_sym_session **sessions;
+	uint32_t i, j;
+	struct multi_session_params ut_paramz[] = {
 
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.aad.len += 1;
-	res = test_authenticated_decryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
-	return TEST_SUCCESS;
-}
+		{
+			.cipher_key = ms_aes_cbc_key0,
+			.hmac_key = ms_hmac_key0,
+			.cipher = ms_aes_cbc_cipher0,
+			.digest = ms_hmac_digest0,
+			.iv = ms_aes_cbc_iv0
+		},
+		{
+			.cipher_key = ms_aes_cbc_key1,
+			.hmac_key = ms_hmac_key1,
+			.cipher = ms_aes_cbc_cipher1,
+			.digest = ms_hmac_digest1,
+			.iv = ms_aes_cbc_iv1
+		},
+		{
+			.cipher_key = ms_aes_cbc_key2,
+			.hmac_key = ms_hmac_key2,
+			.cipher = ms_aes_cbc_cipher2,
+			.digest = ms_hmac_digest2,
+			.iv = ms_aes_cbc_iv2
+		},
 
-static int
-test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
-{
-	struct aead_test_data tdata;
-	uint8_t aad[gcm_test_case_7.aad.len];
-	int res;
+	};
 
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
-	aad[0] += 1;
-	tdata.aad.data = aad;
-	res = test_authenticated_decryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
-	return TEST_SUCCESS;
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
-{
-	struct aead_test_data tdata;
-	int res;
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-	memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
-	tdata.auth_tag.data[0] += 1;
-	res = test_authenticated_decryption(&tdata);
-	TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
-	return TEST_SUCCESS;
-}
+	sessions = rte_malloc(NULL,
+			(sizeof(struct rte_cryptodev_sym_session *)
+					* MAX_NB_SESSIONS) + 1, 0);
 
-static int
-test_authenticated_encryption_oop(const struct aead_test_data *tdata)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-
-	int retval;
-	uint8_t *ciphertext, *auth_tag;
-	uint16_t plaintext_pad_len;
-
-	/* Create AEAD session */
-	retval = create_aead_session(ts_params->valid_devs[0],
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_ENCRYPT,
-			tdata->key.data, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
-
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
-	memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->obuf));
+	for (i = 0; i < MB_SESSION_NUMBER; i++) {
+		sessions[i] = rte_cryptodev_sym_session_create(
+				ts_params->session_mpool);
 
-	/* Create AEAD operation */
-	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
-	if (retval < 0)
-		return retval;
+		rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
+				sizeof(struct crypto_unittest_params));
 
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+		test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
+				&ut_paramz[i].ut_params,
+				ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
 
-	ut_params->op->sym->m_src = ut_params->ibuf;
-	ut_params->op->sym->m_dst = ut_params->obuf;
+		/* Create multiple crypto sessions*/
+		rte_cryptodev_sym_session_init(
+				ts_params->valid_devs[0],
+				sessions[i],
+				&ut_paramz[i].ut_params.auth_xform,
+				ts_params->session_priv_mpool);
 
-	/* Process crypto operation */
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+		TEST_ASSERT_NOT_NULL(sessions[i],
+				"Session creation failed at session number %u",
+				i);
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
+	}
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+	srand(time(NULL));
+	for (i = 0; i < 40000; i++) {
 
-	ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
-			ut_params->op->sym->cipher.data.offset);
-	auth_tag = ciphertext + plaintext_pad_len;
+		j = rand() % MB_SESSION_NUMBER;
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
-	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
+		TEST_ASSERT_SUCCESS(
+			test_AES_CBC_HMAC_SHA512_decrypt_perform(
+					sessions[j],
+					&ut_paramz[j].ut_params,
+					ts_params, ut_paramz[j].cipher,
+					ut_paramz[j].digest,
+					ut_paramz[j].iv),
+			"Failed to perform decrypt on request number %u.", i);
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->ciphertext.len,
-			"Ciphertext data not as expected");
+		if (ut_paramz[j].ut_params.op)
+			rte_crypto_op_free(ut_paramz[j].ut_params.op);
 
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			auth_tag,
-			tdata->auth_tag.data,
-			tdata->auth_tag.len,
-			"Generated auth tag not as expected");
+		/*
+		 * free mbuf - both obuf and ibuf are usually the same,
+		 * so check if they point at the same address is necessary,
+		 * to avoid freeing the mbuf twice.
+		 */
+		if (ut_paramz[j].ut_params.obuf) {
+			rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
+			if (ut_paramz[j].ut_params.ibuf
+					== ut_paramz[j].ut_params.obuf)
+				ut_paramz[j].ut_params.ibuf = 0;
+			ut_paramz[j].ut_params.obuf = 0;
+		}
+		if (ut_paramz[j].ut_params.ibuf) {
+			rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
+			ut_paramz[j].ut_params.ibuf = 0;
+		}
+	}
 
-	return 0;
+	for (i = 0; i < MB_SESSION_NUMBER; i++) {
+		rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
+				sessions[i]);
+		rte_cryptodev_sym_session_free(sessions[i]);
+	}
 
-}
+	rte_free(sessions);
 
-static int
-test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
-{
-	return test_authenticated_encryption_oop(&gcm_test_case_5);
+	return TEST_SUCCESS;
 }
 
 static int
-test_authenticated_decryption_oop(const struct aead_test_data *tdata)
+test_null_cipher_only_operation(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	int retval;
-	uint8_t *plaintext;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* Create AEAD session */
-	retval = create_aead_session(ts_params->valid_devs[0],
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_DECRYPT,
-			tdata->key.data, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
+	/* Generate test mbuf data and space for digest */
+	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
+			catch_22_quote, QUOTE_512_BYTES, 0);
 
-	/* alloc mbuf and set payload */
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = NULL;
 
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
-	memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->obuf));
+	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 
-	/* Create AEAD operation */
-	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
-	if (retval < 0)
-		return retval;
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
+
+	/* Create Crypto session*/
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+				ut_params->sess,
+				&ut_params->cipher_xform,
+				ts_params->session_priv_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
+	/* Set crypto operation data parameters */
 	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	ut_params->op->sym->m_src = ut_params->ibuf;
-	ut_params->op->sym->m_dst = ut_params->obuf;
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	/* Process crypto operation */
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
+	sym_op->cipher.data.offset = 0;
+	sym_op->cipher.data.length = QUOTE_512_BYTES;
 
-	plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
-			ut_params->op->sym->cipher.data.offset);
+	/* Process crypto operation */
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
 
-	debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto operation processing failed");
 
 	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len,
-			"Plaintext data not as expected");
-
-	TEST_ASSERT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"Authentication failed");
-	return 0;
-}
+			rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
+			catch_22_quote,
+			QUOTE_512_BYTES,
+			"Ciphertext data not as expected");
 
-static int
-test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
-{
-	return test_authenticated_decryption_oop(&gcm_test_case_5);
+	return TEST_SUCCESS;
 }
-
+uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
+			0xab, 0xab, 0xab, 0xab,
+			0xab, 0xab, 0xab, 0xab,
+			0xab, 0xab, 0xab, 0xab};
 static int
-test_authenticated_encryption_sessionless(
-		const struct aead_test_data *tdata)
+test_null_auth_only_operation(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *digest;
 
-	int retval;
-	uint8_t *ciphertext, *auth_tag;
-	uint16_t plaintext_pad_len;
-	uint8_t key[tdata->key.len + 1];
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	/* Generate test mbuf data and space for digest */
+	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
+			catch_22_quote, QUOTE_512_BYTES, 0);
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+	/* create a pointer for digest, but don't expect anything to be written
+	 * here in a NULL auth algo so no mbuf append done.
+	 */
+	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			QUOTE_512_BYTES);
+	/* prefill the memory pointed to by digest */
+	memcpy(digest, orig_data, sizeof(orig_data));
 
-	/* Create AEAD operation */
-	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
-	if (retval < 0)
-		return retval;
+	/* Setup HMAC Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-	/* Create GCM xform */
-	memcpy(key, tdata->key.data, tdata->key.len);
-	retval = create_aead_xform(ut_params->op,
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_ENCRYPT,
-			key, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
-
-	ut_params->op->sym->m_src = ut_params->ibuf;
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-	TEST_ASSERT_EQUAL(ut_params->op->sess_type,
-			RTE_CRYPTO_OP_SESSIONLESS,
-			"crypto op session type not sessionless");
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	/* Process crypto operation */
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+	/* Create Crypto session*/
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			ut_params->sess, &ut_params->auth_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op status not success");
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
-			ut_params->op->sym->cipher.data.offset);
-	auth_tag = ciphertext + plaintext_pad_len;
+	sym_op->m_src = ut_params->ibuf;
 
-	debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
-	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
+	sym_op->auth.data.offset = 0;
+	sym_op->auth.data.length = QUOTE_512_BYTES;
+	sym_op->auth.digest.data = digest;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
+			QUOTE_512_BYTES);
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ciphertext,
-			tdata->ciphertext.data,
-			tdata->ciphertext.len,
-			"Ciphertext data not as expected");
+	/* Process crypto operation */
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
 
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto operation processing failed");
+	/* Make sure memory pointed to by digest hasn't been overwritten */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			auth_tag,
-			tdata->auth_tag.data,
-			tdata->auth_tag.len,
-			"Generated auth tag not as expected");
-
-	return 0;
+			orig_data,
+			digest,
+			sizeof(orig_data),
+			"Memory at digest ptr overwritten unexpectedly");
 
+	return TEST_SUCCESS;
 }
 
-static int
-test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
-{
-	return test_authenticated_encryption_sessionless(
-			&gcm_test_case_5);
-}
 
 static int
-test_authenticated_decryption_sessionless(
-		const struct aead_test_data *tdata)
+test_null_cipher_auth_operation(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *digest;
 
-	int retval;
-	uint8_t *plaintext;
-	uint8_t key[tdata->key.len + 1];
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	/* alloc mbuf and set payload */
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	/* Generate test mbuf data and space for digest */
+	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
+			catch_22_quote, QUOTE_512_BYTES, 0);
 
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+	/* create a pointer for digest, but don't expect anything to be written
+	 * here in a NULL auth algo so no mbuf append done.
+	 */
+	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			QUOTE_512_BYTES);
+	/* prefill the memory pointed to by digest */
+	memcpy(digest, orig_data, sizeof(orig_data));
 
-	/* Create AEAD operation */
-	retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
-	if (retval < 0)
-		return retval;
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = &ut_params->auth_xform;
 
-	/* Create AEAD xform */
-	memcpy(key, tdata->key.data, tdata->key.len);
-	retval = create_aead_xform(ut_params->op,
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_DECRYPT,
-			key, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
+	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 
-	ut_params->op->sym->m_src = ut_params->ibuf;
+	/* Setup HMAC Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-	TEST_ASSERT_EQUAL(ut_params->op->sess_type,
-			RTE_CRYPTO_OP_SESSIONLESS,
-			"crypto op session type not sessionless");
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-	/* Process crypto operation */
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
+	/* Create Crypto session*/
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			ut_params->sess, &ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op status not success");
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
-	plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
-			ut_params->op->sym->cipher.data.offset);
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			plaintext,
-			tdata->plaintext.data,
-			tdata->plaintext.len,
-			"Plaintext data not as expected");
+	sym_op->m_src = ut_params->ibuf;
 
-	TEST_ASSERT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"Authentication failed");
-	return 0;
-}
+	sym_op->cipher.data.offset = 0;
+	sym_op->cipher.data.length = QUOTE_512_BYTES;
 
-static int
-test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
-{
-	return test_authenticated_decryption_sessionless(
-			&gcm_test_case_5);
-}
+	sym_op->auth.data.offset = 0;
+	sym_op->auth.data.length = QUOTE_512_BYTES;
+	sym_op->auth.digest.data = digest;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
+			QUOTE_512_BYTES);
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_128_1(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_128_1);
-}
+	/* Process crypto operation */
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_128_2(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_128_2);
-}
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto operation processing failed");
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_128_3(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_128_3);
-}
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
+			catch_22_quote,
+			QUOTE_512_BYTES,
+			"Ciphertext data not as expected");
+	/* Make sure memory pointed to by digest hasn't been overwritten */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			orig_data,
+			digest,
+			sizeof(orig_data),
+			"Memory at digest ptr overwritten unexpectedly");
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_128_1(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_128_1);
+	return TEST_SUCCESS;
 }
 
 static int
-test_AES_CCM_authenticated_decryption_test_case_128_2(void)
+test_null_auth_cipher_operation(void)
 {
-	return test_authenticated_decryption(&ccm_test_case_128_2);
-}
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *digest;
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_128_3(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_128_3);
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_192_1(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_192_1);
-}
+	/* Generate test mbuf data */
+	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
+			catch_22_quote, QUOTE_512_BYTES, 0);
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_192_2(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_192_2);
-}
+	/* create a pointer for digest, but don't expect anything to be written
+	 * here in a NULL auth algo so no mbuf append done.
+	 */
+	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+				QUOTE_512_BYTES);
+	/* prefill the memory pointed to by digest */
+	memcpy(digest, orig_data, sizeof(orig_data));
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_192_3(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_192_3);
-}
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = NULL;
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_192_1(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_192_1);
-}
+	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_192_2(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_192_2);
-}
+	/* Setup HMAC Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = &ut_params->cipher_xform;
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_192_3(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_192_3);
-}
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_256_1(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_256_1);
-}
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_256_2(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_256_2);
-}
+	/* Create Crypto session*/
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			ut_params->sess, &ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-static int
-test_AES_CCM_authenticated_encryption_test_case_256_3(void)
-{
-	return test_authenticated_encryption(&ccm_test_case_256_3);
-}
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate symmetric crypto operation struct");
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_256_1(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_256_1);
-}
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_256_2(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_256_2);
-}
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-static int
-test_AES_CCM_authenticated_decryption_test_case_256_3(void)
-{
-	return test_authenticated_decryption(&ccm_test_case_256_3);
-}
+	sym_op->m_src = ut_params->ibuf;
 
-static int
-test_stats(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct rte_cryptodev_stats stats;
-	struct rte_cryptodev *dev;
-	cryptodev_stats_get_t temp_pfn;
+	sym_op->cipher.data.offset = 0;
+	sym_op->cipher.data.length = QUOTE_512_BYTES;
 
-	rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
-	TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
-			&stats) == -ENODEV),
-		"rte_cryptodev_stats_get invalid dev failed");
-	TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
-		"rte_cryptodev_stats_get invalid Param failed");
-	dev = &rte_cryptodevs[ts_params->valid_devs[0]];
-	temp_pfn = dev->dev_ops->stats_get;
-	dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
-	TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
-			== -ENOTSUP),
-		"rte_cryptodev_stats_get invalid Param failed");
-	dev->dev_ops->stats_get = temp_pfn;
+	sym_op->auth.data.offset = 0;
+	sym_op->auth.data.length = QUOTE_512_BYTES;
+	sym_op->auth.digest.data = digest;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
+					QUOTE_512_BYTES);
 
-	/* Test expected values */
-	ut_setup();
-	test_AES_CBC_HMAC_SHA1_encrypt_digest();
-	ut_teardown();
-	TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
-			&stats),
-		"rte_cryptodev_stats_get failed");
-	TEST_ASSERT((stats.enqueued_count == 1),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
-	TEST_ASSERT((stats.dequeued_count == 1),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
-	TEST_ASSERT((stats.enqueue_err_count == 0),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
-	TEST_ASSERT((stats.dequeue_err_count == 0),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	/* Process crypto operation */
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
 
-	/* invalid device but should ignore and not reset device stats*/
-	rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
-	TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
-			&stats),
-		"rte_cryptodev_stats_get failed");
-	TEST_ASSERT((stats.enqueued_count == 1),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto operation processing failed");
 
-	/* check that a valid reset clears stats */
-	rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
-	TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
-			&stats),
-					  "rte_cryptodev_stats_get failed");
-	TEST_ASSERT((stats.enqueued_count == 0),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
-	TEST_ASSERT((stats.dequeued_count == 0),
-		"rte_cryptodev_stats_get returned unexpected enqueued stat");
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
+			catch_22_quote,
+			QUOTE_512_BYTES,
+			"Ciphertext data not as expected");
+	/* Make sure memory pointed to by digest hasn't been overwritten */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			orig_data,
+			digest,
+			sizeof(orig_data),
+			"Memory at digest ptr overwritten unexpectedly");
 
 	return TEST_SUCCESS;
 }
 
-static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
-				   struct crypto_unittest_params *ut_params,
-				   enum rte_crypto_auth_operation op,
-				   const struct HMAC_MD5_vector *test_case)
+
+static int
+test_null_invalid_operation(void)
 {
-	uint8_t key[64];
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+	int ret;
 
-	memcpy(key, test_case->key.data, test_case->key.len);
+	/* This test is for NULL PMD only */
+	if (gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
+		return -ENOTSUP;
+
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = NULL;
+
+	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
+
+	/* Create Crypto session*/
+	ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			ut_params->sess, &ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT(ret < 0,
+			"Session creation succeeded unexpectedly");
 
+
+	/* Setup HMAC Parameters */
 	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 	ut_params->auth_xform.next = NULL;
-	ut_params->auth_xform.auth.op = op;
-
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
 
-	ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
-	ut_params->auth_xform.auth.key.length = test_case->key.len;
-	ut_params->auth_xform.auth.key.data = key;
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
 	ut_params->sess = rte_cryptodev_sym_session_create(
 			ts_params->session_mpool);
 
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+	/* Create Crypto session*/
+	ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
 			ut_params->sess, &ut_params->auth_xform,
 			ts_params->session_priv_mpool);
+	TEST_ASSERT(ret < 0,
+			"Session creation succeeded unexpectedly");
 
-	if (ut_params->sess == NULL)
-		return TEST_FAILED;
-
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	return TEST_SUCCESS;
+}
 
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	return 0;
-}
+#define NULL_BURST_LENGTH (32)
 
-static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
-			      const struct HMAC_MD5_vector *test_case,
-			      uint8_t **plaintext)
+static int
+test_null_burst_operation(void)
 {
-	uint16_t plaintext_pad_len;
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	unsigned i, burst_len = NULL_BURST_LENGTH;
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
-				16);
+	struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
+	struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
 
-	*plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			plaintext_pad_len);
-	memcpy(*plaintext, test_case->plaintext.data,
-			test_case->plaintext.len);
+	/* This test is for NULL PMD only */
+	if (gbl_driver_id != rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
+		return -ENOTSUP;
 
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, MD5_DIGEST_LEN);
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append digest");
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, plaintext_pad_len);
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = &ut_params->auth_xform;
 
-	if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
-		rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
-			   test_case->auth_tag.len);
-	}
+	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 
-	sym_op->auth.data.offset = 0;
-	sym_op->auth.data.length = test_case->plaintext.len;
+	/* Setup HMAC Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-	ut_params->op->sym->m_src = ut_params->ibuf;
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-	return 0;
-}
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-static int
-test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
-{
-	uint16_t plaintext_pad_len;
-	uint8_t *plaintext, *auth_tag;
+	/* Create Crypto session*/
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+			ut_params->sess, &ut_params->cipher_xform,
+			ts_params->session_priv_mpool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
+			burst_len, "failed to generate burst of crypto ops");
 
-	if (MD5_HMAC_create_session(ts_params, ut_params,
-			RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
-		return TEST_FAILED;
+	/* Generate an operation for each mbuf in burst */
+	for (i = 0; i < burst_len; i++) {
+		struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
+		TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
-				16);
+		unsigned *data = (unsigned *)rte_pktmbuf_append(m,
+				sizeof(unsigned));
+		*data = i;
 
-	if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
-		return TEST_FAILED;
+		rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
 
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+		burst[i]->sym->m_src = m;
+	}
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
+	/* Process crypto operation */
+	TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
+			0, burst, burst_len),
+			burst_len,
+			"Error enqueuing burst");
 
-	if (ut_params->op->sym->m_dst) {
-		auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
-				uint8_t *, plaintext_pad_len);
-	} else {
-		auth_tag = plaintext + plaintext_pad_len;
-	}
+	TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
+			0, burst_dequeued, burst_len),
+			burst_len,
+			"Error dequeuing burst");
 
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			auth_tag,
-			test_case->auth_tag.data,
-			test_case->auth_tag.len,
-			"HMAC_MD5 generated tag not as expected");
+
+	for (i = 0; i < burst_len; i++) {
+		TEST_ASSERT_EQUAL(
+			*rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
+			*rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
+					uint32_t *),
+			"data not as expected");
+
+		rte_pktmbuf_free(burst[i]->sym->m_src);
+		rte_crypto_op_free(burst[i]);
+	}
 
 	return TEST_SUCCESS;
 }
 
-static int
-test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
+static void
+generate_gmac_large_plaintext(uint8_t *data)
 {
-	uint8_t *plaintext;
+	uint16_t i;
+
+	for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
+		memcpy(&data[i], &data[0], 32);
+}
 
+static int
+create_gmac_operation(enum rte_crypto_auth_operation op,
+		const struct gmac_test_data *tdata)
+{
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct rte_crypto_sym_op *sym_op;
 
-	if (MD5_HMAC_create_session(ts_params, ut_params,
-			RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
-		return TEST_FAILED;
-	}
+	uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
 
 	/* Generate Crypto op data structure */
 	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
@@ -9607,3337 +9648,1966 @@  test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
 	TEST_ASSERT_NOT_NULL(ut_params->op,
 			"Failed to allocate symmetric crypto operation struct");
 
-	if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
-		return TEST_FAILED;
+	sym_op = ut_params->op->sym;
 
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+			ut_params->ibuf, tdata->gmac_tag.len);
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+			"no room to append digest");
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"HMAC_MD5 crypto op processing failed");
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			ut_params->ibuf, plaintext_pad_len);
 
-	return TEST_SUCCESS;
-}
+	if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
+		rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
+				tdata->gmac_tag.len);
+		debug_hexdump(stdout, "digest:",
+				sym_op->auth.digest.data,
+				tdata->gmac_tag.len);
+	}
 
-static int
-test_MD5_HMAC_generate_case_1(void)
-{
-	return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
-}
+	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+			uint8_t *, IV_OFFSET);
 
-static int
-test_MD5_HMAC_verify_case_1(void)
-{
-	return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
-}
+	rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
 
-static int
-test_MD5_HMAC_generate_case_2(void)
-{
-	return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
-}
+	debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
 
-static int
-test_MD5_HMAC_verify_case_2(void)
-{
-	return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
+	sym_op->cipher.data.length = 0;
+	sym_op->cipher.data.offset = 0;
+
+	sym_op->auth.data.offset = 0;
+	sym_op->auth.data.length = tdata->plaintext.len;
+
+	return 0;
 }
 
-static int
-test_multi_session(void)
+static int create_gmac_session(uint8_t dev_id,
+		const struct gmac_test_data *tdata,
+		enum rte_crypto_auth_operation auth_op)
 {
+	uint8_t auth_key[tdata->key.len];
+
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
 
-	struct rte_cryptodev_info dev_info;
-	struct rte_cryptodev_sym_session **sessions;
+	memcpy(auth_key, tdata->key.data, tdata->key.len);
 
-	uint16_t i;
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.next = NULL;
 
-	test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
-			aes_cbc_key, hmac_sha512_key);
+	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
+	ut_params->auth_xform.auth.op = auth_op;
+	ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
+	ut_params->auth_xform.auth.key.length = tdata->key.len;
+	ut_params->auth_xform.auth.key.data = auth_key;
+	ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+	ut_params->auth_xform.auth.iv.length = tdata->iv.len;
 
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	sessions = rte_malloc(NULL,
-			(sizeof(struct rte_cryptodev_sym_session *) *
-			MAX_NB_SESSIONS) + 1, 0);
+	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+			&ut_params->auth_xform,
+			ts_params->session_priv_mpool);
 
-	/* Create multiple crypto sessions*/
-	for (i = 0; i < MAX_NB_SESSIONS; i++) {
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-		sessions[i] = rte_cryptodev_sym_session_create(
-				ts_params->session_mpool);
+	return 0;
+}
 
-		rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-				sessions[i], &ut_params->auth_xform,
-				ts_params->session_priv_mpool);
-		TEST_ASSERT_NOT_NULL(sessions[i],
-				"Session creation failed at session number %u",
-				i);
+static int
+test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
 
-		/* Attempt to send a request on each session */
-		TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
-			sessions[i],
-			ut_params,
-			ts_params,
-			catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
-			catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
-			aes_cbc_iv),
-			"Failed to perform decrypt on request number %u.", i);
-		/* free crypto operation structure */
-		if (ut_params->op)
-			rte_crypto_op_free(ut_params->op);
+	int retval;
 
-		/*
-		 * free mbuf - both obuf and ibuf are usually the same,
-		 * so check if they point at the same address is necessary,
-		 * to avoid freeing the mbuf twice.
-		 */
-		if (ut_params->obuf) {
-			rte_pktmbuf_free(ut_params->obuf);
-			if (ut_params->ibuf == ut_params->obuf)
-				ut_params->ibuf = 0;
-			ut_params->obuf = 0;
-		}
-		if (ut_params->ibuf) {
-			rte_pktmbuf_free(ut_params->ibuf);
-			ut_params->ibuf = 0;
-		}
-	}
+	uint8_t *auth_tag, *plaintext;
+	uint16_t plaintext_pad_len;
 
-	/* Next session create should fail */
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			sessions[i], &ut_params->auth_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_NULL(sessions[i],
-			"Session creation succeeded unexpectedly!");
+	TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
+			      "No GMAC length in the source data");
 
-	for (i = 0; i < MAX_NB_SESSIONS; i++) {
-		rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
-				sessions[i]);
-		rte_cryptodev_sym_session_free(sessions[i]);
-	}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	rte_free(sessions);
+	retval = create_gmac_session(ts_params->valid_devs[0],
+			tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
 
-	return TEST_SUCCESS;
-}
+	if (retval < 0)
+		return retval;
 
-struct multi_session_params {
-	struct crypto_unittest_params ut_params;
-	uint8_t *cipher_key;
-	uint8_t *hmac_key;
-	const uint8_t *cipher;
-	const uint8_t *digest;
-	uint8_t *iv;
-};
-
-#define MB_SESSION_NUMBER 3
+	if (tdata->plaintext.len > MBUF_SIZE)
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+	else
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
 
-static int
-test_multi_session_random_usage(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct rte_cryptodev_info dev_info;
-	struct rte_cryptodev_sym_session **sessions;
-	uint32_t i, j;
-	struct multi_session_params ut_paramz[] = {
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-		{
-			.cipher_key = ms_aes_cbc_key0,
-			.hmac_key = ms_hmac_key0,
-			.cipher = ms_aes_cbc_cipher0,
-			.digest = ms_hmac_digest0,
-			.iv = ms_aes_cbc_iv0
-		},
-		{
-			.cipher_key = ms_aes_cbc_key1,
-			.hmac_key = ms_hmac_key1,
-			.cipher = ms_aes_cbc_cipher1,
-			.digest = ms_hmac_digest1,
-			.iv = ms_aes_cbc_iv1
-		},
-		{
-			.cipher_key = ms_aes_cbc_key2,
-			.hmac_key = ms_hmac_key2,
-			.cipher = ms_aes_cbc_cipher2,
-			.digest = ms_hmac_digest2,
-			.iv = ms_aes_cbc_iv2
-		},
+	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+	/*
+	 * Runtime generate the large plain text instead of use hard code
+	 * plain text vector. It is done to avoid create huge source file
+	 * with the test vector.
+	 */
+	if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
+		generate_gmac_large_plaintext(tdata->plaintext.data);
 
-	};
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
-	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+	debug_hexdump(stdout, "plaintext:", plaintext,
+			tdata->plaintext.len);
 
-	sessions = rte_malloc(NULL,
-			(sizeof(struct rte_cryptodev_sym_session *)
-					* MAX_NB_SESSIONS) + 1, 0);
+	retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
+			tdata);
 
-	for (i = 0; i < MB_SESSION_NUMBER; i++) {
-		sessions[i] = rte_cryptodev_sym_session_create(
-				ts_params->session_mpool);
+	if (retval < 0)
+		return retval;
 
-		rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
-				sizeof(struct crypto_unittest_params));
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-		test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
-				&ut_paramz[i].ut_params,
-				ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
+	ut_params->op->sym->m_src = ut_params->ibuf;
 
-		/* Create multiple crypto sessions*/
-		rte_cryptodev_sym_session_init(
-				ts_params->valid_devs[0],
-				sessions[i],
-				&ut_paramz[i].ut_params.auth_xform,
-				ts_params->session_priv_mpool);
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
-		TEST_ASSERT_NOT_NULL(sessions[i],
-				"Session creation failed at session number %u",
-				i);
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
 
+	if (ut_params->op->sym->m_dst) {
+		auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
+				uint8_t *, plaintext_pad_len);
+	} else {
+		auth_tag = plaintext + plaintext_pad_len;
 	}
 
-	srand(time(NULL));
-	for (i = 0; i < 40000; i++) {
-
-		j = rand() % MB_SESSION_NUMBER;
+	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
 
-		TEST_ASSERT_SUCCESS(
-			test_AES_CBC_HMAC_SHA512_decrypt_perform(
-					sessions[j],
-					&ut_paramz[j].ut_params,
-					ts_params, ut_paramz[j].cipher,
-					ut_paramz[j].digest,
-					ut_paramz[j].iv),
-			"Failed to perform decrypt on request number %u.", i);
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			auth_tag,
+			tdata->gmac_tag.data,
+			tdata->gmac_tag.len,
+			"GMAC Generated auth tag not as expected");
 
-		if (ut_paramz[j].ut_params.op)
-			rte_crypto_op_free(ut_paramz[j].ut_params.op);
+	return 0;
+}
 
-		/*
-		 * free mbuf - both obuf and ibuf are usually the same,
-		 * so check if they point at the same address is necessary,
-		 * to avoid freeing the mbuf twice.
-		 */
-		if (ut_paramz[j].ut_params.obuf) {
-			rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
-			if (ut_paramz[j].ut_params.ibuf
-					== ut_paramz[j].ut_params.obuf)
-				ut_paramz[j].ut_params.ibuf = 0;
-			ut_paramz[j].ut_params.obuf = 0;
-		}
-		if (ut_paramz[j].ut_params.ibuf) {
-			rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
-			ut_paramz[j].ut_params.ibuf = 0;
-		}
-	}
+static int
+test_AES_GMAC_authentication_test_case_1(void)
+{
+	return test_AES_GMAC_authentication(&gmac_test_case_1);
+}
 
-	for (i = 0; i < MB_SESSION_NUMBER; i++) {
-		rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
-				sessions[i]);
-		rte_cryptodev_sym_session_free(sessions[i]);
-	}
+static int
+test_AES_GMAC_authentication_test_case_2(void)
+{
+	return test_AES_GMAC_authentication(&gmac_test_case_2);
+}
 
-	rte_free(sessions);
+static int
+test_AES_GMAC_authentication_test_case_3(void)
+{
+	return test_AES_GMAC_authentication(&gmac_test_case_3);
+}
 
-	return TEST_SUCCESS;
+static int
+test_AES_GMAC_authentication_test_case_4(void)
+{
+	return test_AES_GMAC_authentication(&gmac_test_case_4);
 }
 
 static int
-test_null_cipher_only_operation(void)
+test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	int retval;
+	uint32_t plaintext_pad_len;
+	uint8_t *plaintext;
 
-	/* Generate test mbuf data and space for digest */
-	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
-			catch_22_quote, QUOTE_512_BYTES, 0);
+	TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
+			      "No GMAC length in the source data");
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = NULL;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+	retval = create_gmac_session(ts_params->valid_devs[0],
+			tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
 
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	if (retval < 0)
+		return retval;
 
-	/* Create Crypto session*/
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-				ut_params->sess,
-				&ut_params->cipher_xform,
-				ts_params->session_priv_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	if (tdata->plaintext.len > MBUF_SIZE)
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
+	else
+		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	/*
+	 * Runtime generate the large plain text instead of use hard code
+	 * plain text vector. It is done to avoid create huge source file
+	 * with the test vector.
+	 */
+	if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
+		generate_gmac_large_plaintext(tdata->plaintext.data);
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				plaintext_pad_len);
+	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
-	sym_op->cipher.data.offset = 0;
-	sym_op->cipher.data.length = QUOTE_512_BYTES;
+	memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+	debug_hexdump(stdout, "plaintext:", plaintext,
+			tdata->plaintext.len);
 
-	/* Process crypto operation */
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+	retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
+			tdata);
+
+	if (retval < 0)
+		return retval;
+
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+
+	ut_params->op->sym->m_src = ut_params->ibuf;
+
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
 	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto operation processing failed");
+			"crypto op processing failed");
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
-			catch_22_quote,
-			QUOTE_512_BYTES,
-			"Ciphertext data not as expected");
+	return 0;
 
-	return TEST_SUCCESS;
 }
-uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
-			0xab, 0xab, 0xab, 0xab,
-			0xab, 0xab, 0xab, 0xab,
-			0xab, 0xab, 0xab, 0xab};
+
 static int
-test_null_auth_only_operation(void)
+test_AES_GMAC_authentication_verify_test_case_1(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	uint8_t *digest;
-
-	/* Generate test mbuf data and space for digest */
-	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
-			catch_22_quote, QUOTE_512_BYTES, 0);
-
-	/* create a pointer for digest, but don't expect anything to be written
-	 * here in a NULL auth algo so no mbuf append done.
-	 */
-	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
-			QUOTE_512_BYTES);
-	/* prefill the memory pointed to by digest */
-	memcpy(digest, orig_data, sizeof(orig_data));
-
-	/* Setup HMAC Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
-
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
-
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
-
-	/* Create Crypto session*/
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			ut_params->sess, &ut_params->auth_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
-
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
-	sym_op->m_src = ut_params->ibuf;
-
-	sym_op->auth.data.offset = 0;
-	sym_op->auth.data.length = QUOTE_512_BYTES;
-	sym_op->auth.digest.data = digest;
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
-			QUOTE_512_BYTES);
-
-	/* Process crypto operation */
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
-
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto operation processing failed");
-	/* Make sure memory pointed to by digest hasn't been overwritten */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			orig_data,
-			digest,
-			sizeof(orig_data),
-			"Memory at digest ptr overwritten unexpectedly");
-
-	return TEST_SUCCESS;
+	return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
 }
 
-
 static int
-test_null_cipher_auth_operation(void)
+test_AES_GMAC_authentication_verify_test_case_2(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	uint8_t *digest;
-
-	/* Generate test mbuf data and space for digest */
-	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
-			catch_22_quote, QUOTE_512_BYTES, 0);
-
-	/* create a pointer for digest, but don't expect anything to be written
-	 * here in a NULL auth algo so no mbuf append done.
-	 */
-	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
-			QUOTE_512_BYTES);
-	/* prefill the memory pointed to by digest */
-	memcpy(digest, orig_data, sizeof(orig_data));
-
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = &ut_params->auth_xform;
-
-	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
-	/* Setup HMAC Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
-
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
-
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
-
-	/* Create Crypto session*/
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			ut_params->sess, &ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
-
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
-	sym_op->m_src = ut_params->ibuf;
-
-	sym_op->cipher.data.offset = 0;
-	sym_op->cipher.data.length = QUOTE_512_BYTES;
-
-	sym_op->auth.data.offset = 0;
-	sym_op->auth.data.length = QUOTE_512_BYTES;
-	sym_op->auth.digest.data = digest;
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
-			QUOTE_512_BYTES);
-
-	/* Process crypto operation */
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
-
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto operation processing failed");
-
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
-			catch_22_quote,
-			QUOTE_512_BYTES,
-			"Ciphertext data not as expected");
-	/* Make sure memory pointed to by digest hasn't been overwritten */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			orig_data,
-			digest,
-			sizeof(orig_data),
-			"Memory at digest ptr overwritten unexpectedly");
+	return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
+}
 
-	return TEST_SUCCESS;
+static int
+test_AES_GMAC_authentication_verify_test_case_3(void)
+{
+	return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
 }
 
 static int
-test_null_auth_cipher_operation(void)
+test_AES_GMAC_authentication_verify_test_case_4(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	uint8_t *digest;
+	return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
+}
 
-	/* Generate test mbuf data */
-	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
-			catch_22_quote, QUOTE_512_BYTES, 0);
+struct test_crypto_vector {
+	enum rte_crypto_cipher_algorithm crypto_algo;
+	unsigned int cipher_offset;
+	unsigned int cipher_len;
 
-	/* create a pointer for digest, but don't expect anything to be written
-	 * here in a NULL auth algo so no mbuf append done.
-	 */
-	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
-				QUOTE_512_BYTES);
-	/* prefill the memory pointed to by digest */
-	memcpy(digest, orig_data, sizeof(orig_data));
+	struct {
+		uint8_t data[64];
+		unsigned int len;
+	} cipher_key;
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = NULL;
+	struct {
+		uint8_t data[64];
+		unsigned int len;
+	} iv;
 
-	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+	struct {
+		const uint8_t *data;
+		unsigned int len;
+	} plaintext;
 
-	/* Setup HMAC Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = &ut_params->cipher_xform;
+	struct {
+		const uint8_t *data;
+		unsigned int len;
+	} ciphertext;
 
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+	enum rte_crypto_auth_algorithm auth_algo;
+	unsigned int auth_offset;
 
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	struct {
+		uint8_t data[128];
+		unsigned int len;
+	} auth_key;
 
-	/* Create Crypto session*/
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			ut_params->sess, &ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	struct {
+		const uint8_t *data;
+		unsigned int len;
+	} aad;
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
+	struct {
+		uint8_t data[128];
+		unsigned int len;
+	} digest;
+};
 
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+static const struct test_crypto_vector
+hmac_sha1_test_crypto_vector = {
+	.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
+	.plaintext = {
+		.data = plaintext_hash,
+		.len = 512
+	},
+	.auth_key = {
+		.data = {
+			0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
+			0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
+			0xDE, 0xF4, 0xDE, 0xAD
+		},
+		.len = 20
+	},
+	.digest = {
+		.data = {
+			0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
+			0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
+			0x3F, 0x91, 0x64, 0x59
+		},
+		.len = 20
+	}
+};
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
-
-	sym_op->m_src = ut_params->ibuf;
-
-	sym_op->cipher.data.offset = 0;
-	sym_op->cipher.data.length = QUOTE_512_BYTES;
-
-	sym_op->auth.data.offset = 0;
-	sym_op->auth.data.length = QUOTE_512_BYTES;
-	sym_op->auth.digest.data = digest;
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
-					QUOTE_512_BYTES);
-
-	/* Process crypto operation */
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+static const struct test_crypto_vector
+aes128_gmac_test_vector = {
+	.auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
+	.plaintext = {
+		.data = plaintext_hash,
+		.len = 512
+	},
+	.iv = {
+		.data = {
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+			0x08, 0x09, 0x0A, 0x0B
+		},
+		.len = 12
+	},
+	.auth_key = {
+		.data = {
+			0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
+			0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
+		},
+		.len = 16
+	},
+	.digest = {
+		.data = {
+			0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
+			0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
+		},
+		.len = 16
+	}
+};
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto operation processing failed");
+static const struct test_crypto_vector
+aes128cbc_hmac_sha1_test_vector = {
+	.crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
+	.cipher_offset = 0,
+	.cipher_len = 512,
+	.cipher_key = {
+		.data = {
+			0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
+			0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
+		},
+		.len = 16
+	},
+	.iv = {
+		.data = {
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+			0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
+		},
+		.len = 16
+	},
+	.plaintext = {
+		.data = plaintext_hash,
+		.len = 512
+	},
+	.ciphertext = {
+		.data = ciphertext512_aes128cbc,
+		.len = 512
+	},
+	.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
+	.auth_offset = 0,
+	.auth_key = {
+		.data = {
+			0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
+			0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
+			0xDE, 0xF4, 0xDE, 0xAD
+		},
+		.len = 20
+	},
+	.digest = {
+		.data = {
+			0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
+			0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
+			0x18, 0x8C, 0x1D, 0x32
+		},
+		.len = 20
+	}
+};
 
-	/* Validate obuf */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
-			catch_22_quote,
-			QUOTE_512_BYTES,
-			"Ciphertext data not as expected");
-	/* Make sure memory pointed to by digest hasn't been overwritten */
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			orig_data,
-			digest,
-			sizeof(orig_data),
-			"Memory at digest ptr overwritten unexpectedly");
+static const struct test_crypto_vector
+aes128cbc_hmac_sha1_aad_test_vector = {
+	.crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
+	.cipher_offset = 12,
+	.cipher_len = 496,
+	.cipher_key = {
+		.data = {
+			0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
+			0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
+		},
+		.len = 16
+	},
+	.iv = {
+		.data = {
+			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+			0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
+		},
+		.len = 16
+	},
+	.plaintext = {
+		.data = plaintext_hash,
+		.len = 512
+	},
+	.ciphertext = {
+		.data = ciphertext512_aes128cbc_aad,
+		.len = 512
+	},
+	.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
+	.auth_offset = 0,
+	.auth_key = {
+		.data = {
+			0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
+			0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
+			0xDE, 0xF4, 0xDE, 0xAD
+		},
+		.len = 20
+	},
+	.digest = {
+		.data = {
+			0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
+			0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
+			0x62, 0x8D, 0x62, 0x65
+		},
+		.len = 20
+	}
+};
 
-	return TEST_SUCCESS;
+static void
+data_corruption(uint8_t *data)
+{
+	data[0] += 1;
 }
 
+static void
+tag_corruption(uint8_t *data, unsigned int tag_offset)
+{
+	data[tag_offset] += 1;
+}
 
 static int
-test_null_invalid_operation(void)
+create_auth_session(struct crypto_unittest_params *ut_params,
+		uint8_t dev_id,
+		const struct test_crypto_vector *reference,
+		enum rte_crypto_auth_operation auth_op)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	int ret;
-
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = NULL;
-
-	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
-
-	/* Create Crypto session*/
-	ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			ut_params->sess, &ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT(ret < 0,
-			"Session creation succeeded unexpectedly");
+	uint8_t auth_key[reference->auth_key.len + 1];
 
+	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
 
-	/* Setup HMAC Parameters */
+	/* Setup Authentication Parameters */
 	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.auth.op = auth_op;
 	ut_params->auth_xform.next = NULL;
+	ut_params->auth_xform.auth.algo = reference->auth_algo;
+	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
+	ut_params->auth_xform.auth.key.data = auth_key;
+	ut_params->auth_xform.auth.digest_length = reference->digest.len;
 
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
-
+	/* Create Crypto session*/
 	ut_params->sess = rte_cryptodev_sym_session_create(
 			ts_params->session_mpool);
 
-	/* Create Crypto session*/
-	ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			ut_params->sess, &ut_params->auth_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT(ret < 0,
-			"Session creation succeeded unexpectedly");
-
-	return TEST_SUCCESS;
-}
+	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+				&ut_params->auth_xform,
+				ts_params->session_priv_mpool);
 
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-#define NULL_BURST_LENGTH (32)
+	return 0;
+}
 
 static int
-test_null_burst_operation(void)
+create_auth_cipher_session(struct crypto_unittest_params *ut_params,
+		uint8_t dev_id,
+		const struct test_crypto_vector *reference,
+		enum rte_crypto_auth_operation auth_op,
+		enum rte_crypto_cipher_operation cipher_op)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-
-	unsigned i, burst_len = NULL_BURST_LENGTH;
-
-	struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
-	struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
-
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = &ut_params->auth_xform;
+	uint8_t cipher_key[reference->cipher_key.len + 1];
+	uint8_t auth_key[reference->auth_key.len + 1];
 
-	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+	memcpy(cipher_key, reference->cipher_key.data,
+			reference->cipher_key.len);
+	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
 
-	/* Setup HMAC Parameters */
+	/* Setup Authentication Parameters */
 	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
-
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+	ut_params->auth_xform.auth.op = auth_op;
+	ut_params->auth_xform.auth.algo = reference->auth_algo;
+	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
+	ut_params->auth_xform.auth.key.data = auth_key;
+	ut_params->auth_xform.auth.digest_length = reference->digest.len;
 
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
+		ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+		ut_params->auth_xform.auth.iv.length = reference->iv.len;
+	} else {
+		ut_params->auth_xform.next = &ut_params->cipher_xform;
+
+		/* Setup Cipher Parameters */
+		ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+		ut_params->cipher_xform.next = NULL;
+		ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
+		ut_params->cipher_xform.cipher.op = cipher_op;
+		ut_params->cipher_xform.cipher.key.data = cipher_key;
+		ut_params->cipher_xform.cipher.key.length =
+				reference->cipher_key.len;
+		ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+		ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+	}
 
 	/* Create Crypto session*/
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-			ut_params->sess, &ut_params->cipher_xform,
-			ts_params->session_priv_mpool);
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
-			burst_len, "failed to generate burst of crypto ops");
+	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+				&ut_params->auth_xform,
+				ts_params->session_priv_mpool);
 
-	/* Generate an operation for each mbuf in burst */
-	for (i = 0; i < burst_len; i++) {
-		struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-		TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
+	return 0;
+}
 
-		unsigned *data = (unsigned *)rte_pktmbuf_append(m,
-				sizeof(unsigned));
-		*data = i;
+static int
+create_auth_operation(struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference,
+		unsigned int auth_generate)
+{
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate pktmbuf offload");
 
-		rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-		burst[i]->sym->m_src = m;
-	}
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	/* Process crypto operation */
-	TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
-			0, burst, burst_len),
-			burst_len,
-			"Error enqueuing burst");
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
-			0, burst_dequeued, burst_len),
-			burst_len,
-			"Error dequeuing burst");
+	/* digest */
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+			ut_params->ibuf, reference->digest.len);
 
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+			"no room to append auth tag");
 
-	for (i = 0; i < burst_len; i++) {
-		TEST_ASSERT_EQUAL(
-			*rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
-			*rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
-					uint32_t *),
-			"data not as expected");
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			ut_params->ibuf, reference->plaintext.len);
 
-		rte_pktmbuf_free(burst[i]->sym->m_src);
-		rte_crypto_op_free(burst[i]);
-	}
+	if (auth_generate)
+		memset(sym_op->auth.digest.data, 0, reference->digest.len);
+	else
+		memcpy(sym_op->auth.digest.data,
+				reference->digest.data,
+				reference->digest.len);
 
-	return TEST_SUCCESS;
-}
+	debug_hexdump(stdout, "digest:",
+			sym_op->auth.digest.data,
+			reference->digest.len);
 
-static void
-generate_gmac_large_plaintext(uint8_t *data)
-{
-	uint16_t i;
+	sym_op->auth.data.length = reference->plaintext.len;
+	sym_op->auth.data.offset = 0;
 
-	for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
-		memcpy(&data[i], &data[0], 32);
+	return 0;
 }
 
 static int
-create_gmac_operation(enum rte_crypto_auth_operation op,
-		const struct gmac_test_data *tdata)
+create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference,
+		unsigned int auth_generate)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	struct rte_crypto_sym_op *sym_op;
-
-	uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
-
 	/* Generate Crypto op data structure */
 	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
 			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate symmetric crypto operation struct");
+			"Failed to allocate pktmbuf offload");
 
-	sym_op = ut_params->op->sym;
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
+	/* digest */
 	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, tdata->gmac_tag.len);
+			ut_params->ibuf, reference->digest.len);
+
 	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append digest");
+			"no room to append auth tag");
 
 	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, plaintext_pad_len);
-
-	if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
-		rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
-				tdata->gmac_tag.len);
-		debug_hexdump(stdout, "digest:",
-				sym_op->auth.digest.data,
-				tdata->gmac_tag.len);
-	}
+			ut_params->ibuf, reference->ciphertext.len);
 
-	uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-			uint8_t *, IV_OFFSET);
+	if (auth_generate)
+		memset(sym_op->auth.digest.data, 0, reference->digest.len);
+	else
+		memcpy(sym_op->auth.digest.data,
+				reference->digest.data,
+				reference->digest.len);
 
-	rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
+	debug_hexdump(stdout, "digest:",
+			sym_op->auth.digest.data,
+			reference->digest.len);
 
-	debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
+	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+			IV_OFFSET), reference->iv.data, reference->iv.len);
 
 	sym_op->cipher.data.length = 0;
 	sym_op->cipher.data.offset = 0;
 
+	sym_op->auth.data.length = reference->plaintext.len;
 	sym_op->auth.data.offset = 0;
-	sym_op->auth.data.length = tdata->plaintext.len;
 
 	return 0;
 }
 
-static int create_gmac_session(uint8_t dev_id,
-		const struct gmac_test_data *tdata,
-		enum rte_crypto_auth_operation auth_op)
+static int
+create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference,
+		unsigned int auth_generate)
 {
-	uint8_t auth_key[tdata->key.len];
+	/* Generate Crypto op data structure */
+	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
+			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+	TEST_ASSERT_NOT_NULL(ut_params->op,
+			"Failed to allocate pktmbuf offload");
 
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	/* Set crypto operation data parameters */
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	memcpy(auth_key, tdata->key.data, tdata->key.len);
+	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
+	/* set crypto operation source mbuf */
+	sym_op->m_src = ut_params->ibuf;
 
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
-	ut_params->auth_xform.auth.op = auth_op;
-	ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
-	ut_params->auth_xform.auth.key.length = tdata->key.len;
-	ut_params->auth_xform.auth.key.data = auth_key;
-	ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
-	ut_params->auth_xform.auth.iv.length = tdata->iv.len;
+	/* digest */
+	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+			ut_params->ibuf, reference->digest.len);
 
+	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+			"no room to append auth tag");
 
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
+			ut_params->ibuf, reference->ciphertext.len);
 
-	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-			&ut_params->auth_xform,
-			ts_params->session_priv_mpool);
+	if (auth_generate)
+		memset(sym_op->auth.digest.data, 0, reference->digest.len);
+	else
+		memcpy(sym_op->auth.digest.data,
+				reference->digest.data,
+				reference->digest.len);
 
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	debug_hexdump(stdout, "digest:",
+			sym_op->auth.digest.data,
+			reference->digest.len);
+
+	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
+			IV_OFFSET), reference->iv.data, reference->iv.len);
+
+	sym_op->cipher.data.length = reference->cipher_len;
+	sym_op->cipher.data.offset = reference->cipher_offset;
+
+	sym_op->auth.data.length = reference->plaintext.len;
+	sym_op->auth.data.offset = reference->auth_offset;
 
 	return 0;
 }
 
 static int
-test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
+create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return create_auth_operation(ts_params, ut_params, reference, 0);
+}
 
-	int retval;
+static int
+create_auth_verify_GMAC_operation(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
+}
 
-	uint8_t *auth_tag, *plaintext;
-	uint16_t plaintext_pad_len;
+static int
+create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
+}
 
-	TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
-			      "No GMAC length in the source data");
+static int
+test_authentication_verify_fail_when_data_corruption(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference,
+		unsigned int data_corrupted)
+{
+	int retval;
 
-	retval = create_gmac_session(ts_params->valid_devs[0],
-			tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
+	uint8_t *plaintext;
 
-	if (retval < 0)
-		return retval;
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = reference->auth_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	if (tdata->plaintext.len > MBUF_SIZE)
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
-	else
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	/* Create session */
+	retval = create_auth_session(ut_params,
+			ts_params->valid_devs[0],
+			reference,
+			RTE_CRYPTO_AUTH_OP_VERIFY);
+	if (retval < 0)
+		return retval;
+
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
 			"Failed to allocate input buffer in mempool");
 
+	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
-	/*
-	 * Runtime generate the large plain text instead of use hard code
-	 * plain text vector. It is done to avoid create huge source file
-	 * with the test vector.
-	 */
-	if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
-		generate_gmac_large_plaintext(tdata->plaintext.data);
-
 	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
+			reference->plaintext.len);
 	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+	memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
 
-	memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
 	debug_hexdump(stdout, "plaintext:", plaintext,
-			tdata->plaintext.len);
+		reference->plaintext.len);
 
-	retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
-			tdata);
+	/* Create operation */
+	retval = create_auth_verify_operation(ts_params, ut_params, reference);
 
 	if (retval < 0)
 		return retval;
 
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	ut_params->op->sym->m_src = ut_params->ibuf;
-
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
-
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
-
-	if (ut_params->op->sym->m_dst) {
-		auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
-				uint8_t *, plaintext_pad_len);
-	} else {
-		auth_tag = plaintext + plaintext_pad_len;
-	}
+	if (data_corrupted)
+		data_corruption(plaintext);
+	else
+		tag_corruption(plaintext, reference->plaintext.len);
 
-	debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
+	TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"authentication not failed");
 
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			auth_tag,
-			tdata->gmac_tag.data,
-			tdata->gmac_tag.len,
-			"GMAC Generated auth tag not as expected");
+	ut_params->obuf = ut_params->op->sym->m_src;
+	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
 
 	return 0;
 }
 
 static int
-test_AES_GMAC_authentication_test_case_1(void)
-{
-	return test_AES_GMAC_authentication(&gmac_test_case_1);
-}
-
-static int
-test_AES_GMAC_authentication_test_case_2(void)
-{
-	return test_AES_GMAC_authentication(&gmac_test_case_2);
-}
-
-static int
-test_AES_GMAC_authentication_test_case_3(void)
-{
-	return test_AES_GMAC_authentication(&gmac_test_case_3);
-}
-
-static int
-test_AES_GMAC_authentication_test_case_4(void)
-{
-	return test_AES_GMAC_authentication(&gmac_test_case_4);
-}
-
-static int
-test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
+test_authentication_verify_GMAC_fail_when_corruption(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference,
+		unsigned int data_corrupted)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
 	int retval;
-	uint32_t plaintext_pad_len;
 	uint8_t *plaintext;
 
-	TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
-			      "No GMAC length in the source data");
-
-	retval = create_gmac_session(ts_params->valid_devs[0],
-			tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = reference->auth_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
+	/* Create session */
+	retval = create_auth_cipher_session(ut_params,
+			ts_params->valid_devs[0],
+			reference,
+			RTE_CRYPTO_AUTH_OP_VERIFY,
+			RTE_CRYPTO_CIPHER_OP_DECRYPT);
 	if (retval < 0)
 		return retval;
 
-	if (tdata->plaintext.len > MBUF_SIZE)
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
-	else
-		ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
 			"Failed to allocate input buffer in mempool");
 
+	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
-
-	/*
-	 * Runtime generate the large plain text instead of use hard code
-	 * plain text vector. It is done to avoid create huge source file
-	 * with the test vector.
-	 */
-	if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
-		generate_gmac_large_plaintext(tdata->plaintext.data);
-
 	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				plaintext_pad_len);
+			reference->plaintext.len);
 	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+	memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
 
-	memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
 	debug_hexdump(stdout, "plaintext:", plaintext,
-			tdata->plaintext.len);
+		reference->plaintext.len);
 
-	retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
-			tdata);
+	/* Create operation */
+	retval = create_auth_verify_GMAC_operation(ts_params,
+			ut_params,
+			reference);
 
 	if (retval < 0)
 		return retval;
 
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	ut_params->op->sym->m_src = ut_params->ibuf;
+	if (data_corrupted)
+		data_corruption(plaintext);
+	else
+		tag_corruption(plaintext, reference->aad.len);
 
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
+	TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"authentication not failed");
 
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
+	ut_params->obuf = ut_params->op->sym->m_src;
+	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
 
 	return 0;
-
 }
 
 static int
-test_AES_GMAC_authentication_verify_test_case_1(void)
+test_authenticated_decryption_fail_when_corruption(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference,
+		unsigned int data_corrupted)
 {
-	return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
-}
+	int retval;
 
-static int
-test_AES_GMAC_authentication_verify_test_case_2(void)
-{
-	return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
-}
+	uint8_t *ciphertext;
 
-static int
-test_AES_GMAC_authentication_verify_test_case_3(void)
-{
-	return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
-}
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = reference->auth_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = reference->crypto_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-static int
-test_AES_GMAC_authentication_verify_test_case_4(void)
-{
-	return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
-}
+	/* Create session */
+	retval = create_auth_cipher_session(ut_params,
+			ts_params->valid_devs[0],
+			reference,
+			RTE_CRYPTO_AUTH_OP_VERIFY,
+			RTE_CRYPTO_CIPHER_OP_DECRYPT);
+	if (retval < 0)
+		return retval;
 
-struct test_crypto_vector {
-	enum rte_crypto_cipher_algorithm crypto_algo;
-	unsigned int cipher_offset;
-	unsigned int cipher_len;
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
 
-	struct {
-		uint8_t data[64];
-		unsigned int len;
-	} cipher_key;
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	struct {
-		uint8_t data[64];
-		unsigned int len;
-	} iv;
+	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+			reference->ciphertext.len);
+	TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
+	memcpy(ciphertext, reference->ciphertext.data,
+			reference->ciphertext.len);
 
-	struct {
-		const uint8_t *data;
-		unsigned int len;
-	} plaintext;
+	/* Create operation */
+	retval = create_cipher_auth_verify_operation(ts_params,
+			ut_params,
+			reference);
 
-	struct {
-		const uint8_t *data;
-		unsigned int len;
-	} ciphertext;
+	if (retval < 0)
+		return retval;
 
-	enum rte_crypto_auth_algorithm auth_algo;
-	unsigned int auth_offset;
+	if (data_corrupted)
+		data_corruption(ciphertext);
+	else
+		tag_corruption(ciphertext, reference->ciphertext.len);
 
-	struct {
-		uint8_t data[128];
-		unsigned int len;
-	} auth_key;
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
 
-	struct {
-		const uint8_t *data;
-		unsigned int len;
-	} aad;
-
-	struct {
-		uint8_t data[128];
-		unsigned int len;
-	} digest;
-};
-
-static const struct test_crypto_vector
-hmac_sha1_test_crypto_vector = {
-	.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
-	.plaintext = {
-		.data = plaintext_hash,
-		.len = 512
-	},
-	.auth_key = {
-		.data = {
-			0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
-			0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
-			0xDE, 0xF4, 0xDE, 0xAD
-		},
-		.len = 20
-	},
-	.digest = {
-		.data = {
-			0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
-			0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
-			0x3F, 0x91, 0x64, 0x59
-		},
-		.len = 20
-	}
-};
-
-static const struct test_crypto_vector
-aes128_gmac_test_vector = {
-	.auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
-	.plaintext = {
-		.data = plaintext_hash,
-		.len = 512
-	},
-	.iv = {
-		.data = {
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-			0x08, 0x09, 0x0A, 0x0B
-		},
-		.len = 12
-	},
-	.auth_key = {
-		.data = {
-			0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
-			0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
-		},
-		.len = 16
-	},
-	.digest = {
-		.data = {
-			0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
-			0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
-		},
-		.len = 16
-	}
-};
-
-static const struct test_crypto_vector
-aes128cbc_hmac_sha1_test_vector = {
-	.crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
-	.cipher_offset = 0,
-	.cipher_len = 512,
-	.cipher_key = {
-		.data = {
-			0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
-			0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
-		},
-		.len = 16
-	},
-	.iv = {
-		.data = {
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-			0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
-		},
-		.len = 16
-	},
-	.plaintext = {
-		.data = plaintext_hash,
-		.len = 512
-	},
-	.ciphertext = {
-		.data = ciphertext512_aes128cbc,
-		.len = 512
-	},
-	.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
-	.auth_offset = 0,
-	.auth_key = {
-		.data = {
-			0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
-			0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
-			0xDE, 0xF4, 0xDE, 0xAD
-		},
-		.len = 20
-	},
-	.digest = {
-		.data = {
-			0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
-			0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
-			0x18, 0x8C, 0x1D, 0x32
-		},
-		.len = 20
-	}
-};
-
-static const struct test_crypto_vector
-aes128cbc_hmac_sha1_aad_test_vector = {
-	.crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
-	.cipher_offset = 12,
-	.cipher_len = 496,
-	.cipher_key = {
-		.data = {
-			0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
-			0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
-		},
-		.len = 16
-	},
-	.iv = {
-		.data = {
-			0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-			0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
-		},
-		.len = 16
-	},
-	.plaintext = {
-		.data = plaintext_hash,
-		.len = 512
-	},
-	.ciphertext = {
-		.data = ciphertext512_aes128cbc_aad,
-		.len = 512
-	},
-	.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
-	.auth_offset = 0,
-	.auth_key = {
-		.data = {
-			0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
-			0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
-			0xDE, 0xF4, 0xDE, 0xAD
-		},
-		.len = 20
-	},
-	.digest = {
-		.data = {
-			0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
-			0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
-			0x62, 0x8D, 0x62, 0x65
-		},
-		.len = 20
-	}
-};
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
+	TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"authentication not failed");
 
-static void
-data_corruption(uint8_t *data)
-{
-	data[0] += 1;
-}
+	ut_params->obuf = ut_params->op->sym->m_src;
+	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
 
-static void
-tag_corruption(uint8_t *data, unsigned int tag_offset)
-{
-	data[tag_offset] += 1;
+	return 0;
 }
 
 static int
-create_auth_session(struct crypto_unittest_params *ut_params,
-		uint8_t dev_id,
-		const struct test_crypto_vector *reference,
-		enum rte_crypto_auth_operation auth_op)
+test_authenticated_encryt_with_esn(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	int retval;
+
+	uint8_t *authciphertext, *plaintext, *auth_tag;
+	uint16_t plaintext_pad_len;
+	uint8_t cipher_key[reference->cipher_key.len + 1];
 	uint8_t auth_key[reference->auth_key.len + 1];
 
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = reference->auth_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = reference->crypto_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+
+	/* Create session */
+	memcpy(cipher_key, reference->cipher_key.data,
+			reference->cipher_key.len);
 	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
 
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+	ut_params->cipher_xform.cipher.key.data = cipher_key;
+	ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
+	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+	ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+
+	ut_params->cipher_xform.next = &ut_params->auth_xform;
+
 	/* Setup Authentication Parameters */
 	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.auth.op = auth_op;
-	ut_params->auth_xform.next = NULL;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 	ut_params->auth_xform.auth.algo = reference->auth_algo;
 	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
 	ut_params->auth_xform.auth.key.data = auth_key;
 	ut_params->auth_xform.auth.digest_length = reference->digest.len;
+	ut_params->auth_xform.next = NULL;
 
 	/* Create Crypto session*/
 	ut_params->sess = rte_cryptodev_sym_session_create(
 			ts_params->session_mpool);
 
-	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-				&ut_params->auth_xform,
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+				ut_params->sess,
+				&ut_params->cipher_xform,
 				ts_params->session_priv_mpool);
 
 	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-	return 0;
-}
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
 
-static int
-create_auth_cipher_session(struct crypto_unittest_params *ut_params,
-		uint8_t dev_id,
-		const struct test_crypto_vector *reference,
-		enum rte_crypto_auth_operation auth_op,
-		enum rte_crypto_cipher_operation cipher_op)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	uint8_t cipher_key[reference->cipher_key.len + 1];
-	uint8_t auth_key[reference->auth_key.len + 1];
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	memcpy(cipher_key, reference->cipher_key.data,
-			reference->cipher_key.len);
-	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+			reference->plaintext.len);
+	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+	memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.auth.op = auth_op;
-	ut_params->auth_xform.auth.algo = reference->auth_algo;
-	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
-	ut_params->auth_xform.auth.key.data = auth_key;
-	ut_params->auth_xform.auth.digest_length = reference->digest.len;
+	/* Create operation */
+	retval = create_cipher_auth_operation(ts_params,
+			ut_params,
+			reference, 0);
 
-	if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
-		ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
-		ut_params->auth_xform.auth.iv.length = reference->iv.len;
-	} else {
-		ut_params->auth_xform.next = &ut_params->cipher_xform;
-
-		/* Setup Cipher Parameters */
-		ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-		ut_params->cipher_xform.next = NULL;
-		ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
-		ut_params->cipher_xform.cipher.op = cipher_op;
-		ut_params->cipher_xform.cipher.key.data = cipher_key;
-		ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
-		ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-		ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
-	}
-
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	if (retval < 0)
+		return retval;
 
-	rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
-				&ut_params->auth_xform,
-				ts_params->session_priv_mpool);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
 
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
 
-	return 0;
-}
+	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing failed");
 
-static int
-create_auth_operation(struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference,
-		unsigned int auth_generate)
-{
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate pktmbuf offload");
+	plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
 
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			ut_params->op->sym->auth.data.offset);
+	auth_tag = authciphertext + plaintext_pad_len;
+	debug_hexdump(stdout, "ciphertext:", authciphertext,
+			reference->ciphertext.len);
+	debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	/* Validate obuf */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			authciphertext,
+			reference->ciphertext.data,
+			reference->ciphertext.len,
+			"Ciphertext data not as expected");
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			auth_tag,
+			reference->digest.data,
+			reference->digest.len,
+			"Generated digest not as expected");
 
-	/* digest */
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, reference->digest.len);
+	return TEST_SUCCESS;
 
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append auth tag");
+}
 
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, reference->plaintext.len);
+static int
+test_authenticated_decrypt_with_esn(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	int retval;
 
-	if (auth_generate)
-		memset(sym_op->auth.digest.data, 0, reference->digest.len);
-	else
-		memcpy(sym_op->auth.digest.data,
-				reference->digest.data,
-				reference->digest.len);
+	uint8_t *ciphertext;
+	uint8_t cipher_key[reference->cipher_key.len + 1];
+	uint8_t auth_key[reference->auth_key.len + 1];
 
-	debug_hexdump(stdout, "digest:",
-			sym_op->auth.digest.data,
-			reference->digest.len);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	cap_idx.algo.auth = reference->auth_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cap_idx.algo.cipher = reference->crypto_algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	sym_op->auth.data.length = reference->plaintext.len;
-	sym_op->auth.data.offset = 0;
+	/* Create session */
+	memcpy(cipher_key, reference->cipher_key.data,
+			reference->cipher_key.len);
+	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
 
-	return 0;
-}
+	/* Setup Authentication Parameters */
+	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
+	ut_params->auth_xform.auth.algo = reference->auth_algo;
+	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
+	ut_params->auth_xform.auth.key.data = auth_key;
+	ut_params->auth_xform.auth.digest_length = reference->digest.len;
+	ut_params->auth_xform.next = &ut_params->cipher_xform;
 
-static int
-create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference,
-		unsigned int auth_generate)
-{
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate pktmbuf offload");
+	/* Setup Cipher Parameters */
+	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	ut_params->cipher_xform.next = NULL;
+	ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
+	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
+	ut_params->cipher_xform.cipher.key.data = cipher_key;
+	ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
+	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+	ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
 
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+	/* Create Crypto session*/
+	ut_params->sess = rte_cryptodev_sym_session_create(
+			ts_params->session_mpool);
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+				ut_params->sess,
+				&ut_params->auth_xform,
+				ts_params->session_priv_mpool);
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
-	/* digest */
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, reference->digest.len);
+	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
+			"Failed to allocate input buffer in mempool");
 
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append auth tag");
+	/* clear mbuf payload */
+	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
+			rte_pktmbuf_tailroom(ut_params->ibuf));
 
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, reference->ciphertext.len);
+	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+			reference->ciphertext.len);
+	TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
+	memcpy(ciphertext, reference->ciphertext.data,
+			reference->ciphertext.len);
 
-	if (auth_generate)
-		memset(sym_op->auth.digest.data, 0, reference->digest.len);
-	else
-		memcpy(sym_op->auth.digest.data,
-				reference->digest.data,
-				reference->digest.len);
+	/* Create operation */
+	retval = create_cipher_auth_verify_operation(ts_params,
+			ut_params,
+			reference);
 
-	debug_hexdump(stdout, "digest:",
-			sym_op->auth.digest.data,
-			reference->digest.len);
+	if (retval < 0)
+		return retval;
 
-	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
-			reference->iv.data, reference->iv.len);
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op);
 
-	sym_op->cipher.data.length = 0;
-	sym_op->cipher.data.offset = 0;
+	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
+	TEST_ASSERT_EQUAL(ut_params->op->status,
+			RTE_CRYPTO_OP_STATUS_SUCCESS,
+			"crypto op processing passed");
 
-	sym_op->auth.data.length = reference->plaintext.len;
-	sym_op->auth.data.offset = 0;
+	ut_params->obuf = ut_params->op->sym->m_src;
+	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
 
 	return 0;
 }
 
 static int
-create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference,
-		unsigned int auth_generate)
+create_aead_operation_SGL(enum rte_crypto_aead_operation op,
+		const struct aead_test_data *tdata,
+		void *digest_mem, uint64_t digest_phys)
 {
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+
+	const unsigned int auth_tag_len = tdata->auth_tag.len;
+	const unsigned int iv_len = tdata->iv.len;
+	unsigned int aad_len = tdata->aad.len;
+
 	/* Generate Crypto op data structure */
 	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
 			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
 	TEST_ASSERT_NOT_NULL(ut_params->op,
-			"Failed to allocate pktmbuf offload");
-
-	/* Set crypto operation data parameters */
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+		"Failed to allocate symmetric crypto operation struct");
 
 	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-	/* set crypto operation source mbuf */
-	sym_op->m_src = ut_params->ibuf;
+	sym_op->aead.digest.data = digest_mem;
 
-	/* digest */
-	sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
-			ut_params->ibuf, reference->digest.len);
+	TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
+			"no room to append digest");
 
-	TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
-			"no room to append auth tag");
+	sym_op->aead.digest.phys_addr = digest_phys;
 
-	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
-			ut_params->ibuf, reference->ciphertext.len);
+	if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
+		rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
+				auth_tag_len);
+		debug_hexdump(stdout, "digest:",
+				sym_op->aead.digest.data,
+				auth_tag_len);
+	}
 
-	if (auth_generate)
-		memset(sym_op->auth.digest.data, 0, reference->digest.len);
-	else
-		memcpy(sym_op->auth.digest.data,
-				reference->digest.data,
-				reference->digest.len);
+	/* Append aad data */
+	if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
+		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+				uint8_t *, IV_OFFSET);
 
-	debug_hexdump(stdout, "digest:",
-			sym_op->auth.digest.data,
-			reference->digest.len);
+		/* Copy IV 1 byte after the IV pointer, according to the API */
+		rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
 
-	rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
-			reference->iv.data, reference->iv.len);
+		aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
 
-	sym_op->cipher.data.length = reference->cipher_len;
-	sym_op->cipher.data.offset = reference->cipher_offset;
+		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
+				ut_params->ibuf, aad_len);
+		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+				"no room to prepend aad");
+		sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
+				ut_params->ibuf);
 
-	sym_op->auth.data.length = reference->plaintext.len;
-	sym_op->auth.data.offset = reference->auth_offset;
+		memset(sym_op->aead.aad.data, 0, aad_len);
+		/* Copy AAD 18 bytes after the AAD ptr, according to the API */
+		rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
 
-	return 0;
-}
+		debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
+		debug_hexdump(stdout, "aad:",
+				sym_op->aead.aad.data, aad_len);
+	} else {
+		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+				uint8_t *, IV_OFFSET);
 
-static int
-create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return create_auth_operation(ts_params, ut_params, reference, 0);
-}
+		rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
 
-static int
-create_auth_verify_GMAC_operation(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
-}
+		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
+				ut_params->ibuf, aad_len);
+		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+				"no room to prepend aad");
+		sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
+				ut_params->ibuf);
 
-static int
-create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
-}
+		memset(sym_op->aead.aad.data, 0, aad_len);
+		rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
 
-static int
-test_authentication_verify_fail_when_data_corruption(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference,
-		unsigned int data_corrupted)
-{
-	int retval;
+		debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
+		debug_hexdump(stdout, "aad:",
+				sym_op->aead.aad.data, aad_len);
+	}
 
-	uint8_t *plaintext;
+	sym_op->aead.data.length = tdata->plaintext.len;
+	sym_op->aead.data.offset = aad_len;
 
-	/* Create session */
-	retval = create_auth_session(ut_params,
-			ts_params->valid_devs[0],
-			reference,
-			RTE_CRYPTO_AUTH_OP_VERIFY);
-	if (retval < 0)
-		return retval;
+	return 0;
+}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
+#define SGL_MAX_NO	16
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+static int
+test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
+		const int oop, uint32_t fragsz, uint32_t fragsz_oop)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
+	int retval;
+	int to_trn = 0;
+	int to_trn_tbl[SGL_MAX_NO];
+	int segs = 1;
+	unsigned int trn_data = 0;
+	uint8_t *plaintext, *ciphertext, *auth_tag;
+	struct rte_cryptodev_info dev_info;
 
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			reference->plaintext.len);
-	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
-	memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
+	/* Verify the capabilities */
+	struct rte_cryptodev_sym_capability_idx cap_idx;
+	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+	cap_idx.algo.aead = tdata->algo;
+	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+			&cap_idx) == NULL)
+		return -ENOTSUP;
 
-	debug_hexdump(stdout, "plaintext:", plaintext,
-		reference->plaintext.len);
+	/* Detailed check for the particular SGL support flag */
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	if (!oop) {
+		unsigned int sgl_in = fragsz < tdata->plaintext.len;
+		if (sgl_in && (!(dev_info.feature_flags &
+				RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
+			return -ENOTSUP;
+	} else {
+		unsigned int sgl_in = fragsz < tdata->plaintext.len;
+		unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
+				tdata->plaintext.len;
+		if (sgl_in && !sgl_out) {
+			if (!(dev_info.feature_flags &
+					RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
+				return -ENOTSUP;
+		} else if (!sgl_in && sgl_out) {
+			if (!(dev_info.feature_flags &
+					RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
+				return -ENOTSUP;
+		} else if (sgl_in && sgl_out) {
+			if (!(dev_info.feature_flags &
+					RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
+				return -ENOTSUP;
+		}
+	}
 
-	/* Create operation */
-	retval = create_auth_verify_operation(ts_params, ut_params, reference);
+	if (fragsz > tdata->plaintext.len)
+		fragsz = tdata->plaintext.len;
 
-	if (retval < 0)
-		return retval;
+	uint16_t plaintext_len = fragsz;
+	uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
 
-	if (data_corrupted)
-		data_corruption(plaintext);
-	else
-		tag_corruption(plaintext, reference->plaintext.len);
+	if (fragsz_oop > tdata->plaintext.len)
+		frag_size_oop = tdata->plaintext.len;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
-	TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"authentication not failed");
+	int ecx = 0;
+	void *digest_mem = NULL;
 
-	ut_params->obuf = ut_params->op->sym->m_src;
-	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+	uint32_t prepend_len = tdata->aad.len;
 
-	return 0;
-}
+	if (tdata->plaintext.len % fragsz != 0) {
+		if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
+			return 1;
+	}	else {
+		if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
+			return 1;
+	}
 
-static int
-test_authentication_verify_GMAC_fail_when_corruption(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference,
-		unsigned int data_corrupted)
-{
-	int retval;
-	uint8_t *plaintext;
+	/*
+	 * For out-op-place we need to alloc another mbuf
+	 */
+	if (oop) {
+		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+		rte_pktmbuf_append(ut_params->obuf,
+				frag_size_oop + prepend_len);
+		buf_oop = ut_params->obuf;
+	}
 
-	/* Create session */
-	retval = create_auth_cipher_session(ut_params,
-			ts_params->valid_devs[0],
-			reference,
-			RTE_CRYPTO_AUTH_OP_VERIFY,
-			RTE_CRYPTO_CIPHER_OP_DECRYPT);
+	/* Create AEAD session */
+	retval = create_aead_session(ts_params->valid_devs[0],
+			tdata->algo,
+			RTE_CRYPTO_AEAD_OP_ENCRYPT,
+			tdata->key.data, tdata->key.len,
+			tdata->aad.len, tdata->auth_tag.len,
+			tdata->iv.len);
 	if (retval < 0)
 		return retval;
 
 	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
 
 	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 			rte_pktmbuf_tailroom(ut_params->ibuf));
 
 	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			reference->plaintext.len);
-	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
-	memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
-
-	debug_hexdump(stdout, "plaintext:", plaintext,
-		reference->plaintext.len);
-
-	/* Create operation */
-	retval = create_auth_verify_GMAC_operation(ts_params,
-			ut_params,
-			reference);
+			plaintext_len);
 
-	if (retval < 0)
-		return retval;
+	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-	if (data_corrupted)
-		data_corruption(plaintext);
-	else
-		tag_corruption(plaintext, reference->aad.len);
+	trn_data += plaintext_len;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
-	TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"authentication not failed");
+	buf = ut_params->ibuf;
 
-	ut_params->obuf = ut_params->op->sym->m_src;
-	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+	/*
+	 * Loop until no more fragments
+	 */
 
-	return 0;
-}
+	while (trn_data < tdata->plaintext.len) {
+		++segs;
+		to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
+				(tdata->plaintext.len - trn_data) : fragsz;
 
-static int
-test_authenticated_decryption_fail_when_corruption(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference,
-		unsigned int data_corrupted)
-{
-	int retval;
+		to_trn_tbl[ecx++] = to_trn;
 
-	uint8_t *ciphertext;
+		buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+		buf = buf->next;
 
-	/* Create session */
-	retval = create_auth_cipher_session(ut_params,
-			ts_params->valid_devs[0],
-			reference,
-			RTE_CRYPTO_AUTH_OP_VERIFY,
-			RTE_CRYPTO_CIPHER_OP_DECRYPT);
-	if (retval < 0)
-		return retval;
+		memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
+				rte_pktmbuf_tailroom(buf));
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
+		/* OOP */
+		if (oop && !fragsz_oop) {
+			buf_last_oop = buf_oop->next =
+					rte_pktmbuf_alloc(ts_params->mbuf_pool);
+			buf_oop = buf_oop->next;
+			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
+					0, rte_pktmbuf_tailroom(buf_oop));
+			rte_pktmbuf_append(buf_oop, to_trn);
+		}
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+		plaintext = (uint8_t *)rte_pktmbuf_append(buf,
+				to_trn);
 
-	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			reference->ciphertext.len);
-	TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
-	memcpy(ciphertext, reference->ciphertext.data,
-			reference->ciphertext.len);
-
-	/* Create operation */
-	retval = create_cipher_auth_verify_operation(ts_params,
-			ut_params,
-			reference);
-
-	if (retval < 0)
-		return retval;
-
-	if (data_corrupted)
-		data_corruption(ciphertext);
-	else
-		tag_corruption(ciphertext, reference->ciphertext.len);
-
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
-
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
-	TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"authentication not failed");
-
-	ut_params->obuf = ut_params->op->sym->m_src;
-	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+		memcpy(plaintext, tdata->plaintext.data + trn_data,
+				to_trn);
+		trn_data += to_trn;
+		if (trn_data  == tdata->plaintext.len) {
+			if (oop) {
+				if (!fragsz_oop)
+					digest_mem = rte_pktmbuf_append(buf_oop,
+						tdata->auth_tag.len);
+			} else
+				digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
+					tdata->auth_tag.len);
+		}
+	}
 
-	return 0;
-}
+	uint64_t digest_phys = 0;
 
-static int
-test_authenticated_encryt_with_esn(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	int retval;
+	ut_params->ibuf->nb_segs = segs;
 
-	uint8_t *authciphertext, *plaintext, *auth_tag;
-	uint16_t plaintext_pad_len;
-	uint8_t cipher_key[reference->cipher_key.len + 1];
-	uint8_t auth_key[reference->auth_key.len + 1];
+	segs = 1;
+	if (fragsz_oop && oop) {
+		to_trn = 0;
+		ecx = 0;
 
-	/* Create session */
-	memcpy(cipher_key, reference->cipher_key.data,
-			reference->cipher_key.len);
-	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+		if (frag_size_oop == tdata->plaintext.len) {
+			digest_mem = rte_pktmbuf_append(ut_params->obuf,
+				tdata->auth_tag.len);
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-	ut_params->cipher_xform.cipher.key.data = cipher_key;
-	ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
-	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-	ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+			digest_phys = rte_pktmbuf_iova_offset(
+					ut_params->obuf,
+					tdata->plaintext.len + prepend_len);
+		}
 
-	ut_params->cipher_xform.next = &ut_params->auth_xform;
+		trn_data = frag_size_oop;
+		while (trn_data < tdata->plaintext.len) {
+			++segs;
+			to_trn =
+				(tdata->plaintext.len - trn_data <
+						frag_size_oop) ?
+				(tdata->plaintext.len - trn_data) :
+						frag_size_oop;
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
-	ut_params->auth_xform.auth.algo = reference->auth_algo;
-	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
-	ut_params->auth_xform.auth.key.data = auth_key;
-	ut_params->auth_xform.auth.digest_length = reference->digest.len;
-	ut_params->auth_xform.next = NULL;
+			to_trn_tbl[ecx++] = to_trn;
 
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+			buf_last_oop = buf_oop->next =
+					rte_pktmbuf_alloc(ts_params->mbuf_pool);
+			buf_oop = buf_oop->next;
+			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
+					0, rte_pktmbuf_tailroom(buf_oop));
+			rte_pktmbuf_append(buf_oop, to_trn);
 
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-				ut_params->sess,
-				&ut_params->cipher_xform,
-				ts_params->session_priv_mpool);
+			trn_data += to_trn;
 
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+			if (trn_data  == tdata->plaintext.len) {
+				digest_mem = rte_pktmbuf_append(buf_oop,
+					tdata->auth_tag.len);
+			}
+		}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
+		ut_params->obuf->nb_segs = segs;
+	}
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+	/*
+	 * Place digest at the end of the last buffer
+	 */
+	if (!digest_phys)
+		digest_phys = rte_pktmbuf_iova(buf) + to_trn;
+	if (oop && buf_last_oop)
+		digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
 
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			reference->plaintext.len);
-	TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
-	memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
+	if (!digest_mem && !oop) {
+		digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+				+ tdata->auth_tag.len);
+		digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
+				tdata->plaintext.len);
+	}
 
-	/* Create operation */
-	retval = create_cipher_auth_operation(ts_params,
-			ut_params,
-			reference, 0);
+	/* Create AEAD operation */
+	retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
+			tdata, digest_mem, digest_phys);
 
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
+	ut_params->op->sym->m_src = ut_params->ibuf;
+	if (oop)
+		ut_params->op->sym->m_dst = ut_params->obuf;
+
+	/* Process crypto operation */
+	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+			ut_params->op), "failed to process sym crypto op");
 
 	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
 			"crypto op processing failed");
 
-	plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
 
-	authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
-			ut_params->op->sym->auth.data.offset);
-	auth_tag = authciphertext + plaintext_pad_len;
-	debug_hexdump(stdout, "ciphertext:", authciphertext,
-			reference->ciphertext.len);
-	debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
+	ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
+			uint8_t *, prepend_len);
+	if (oop) {
+		ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
+				uint8_t *, prepend_len);
+	}
+
+	if (fragsz_oop)
+		fragsz = fragsz_oop;
 
-	/* Validate obuf */
 	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			authciphertext,
-			reference->ciphertext.data,
-			reference->ciphertext.len,
+			ciphertext,
+			tdata->ciphertext.data,
+			fragsz,
 			"Ciphertext data not as expected");
 
+	buf = ut_params->op->sym->m_src->next;
+	if (oop)
+		buf = ut_params->op->sym->m_dst->next;
+
+	unsigned int off = fragsz;
+
+	ecx = 0;
+	while (buf) {
+		ciphertext = rte_pktmbuf_mtod(buf,
+				uint8_t *);
+
+		TEST_ASSERT_BUFFERS_ARE_EQUAL(
+				ciphertext,
+				tdata->ciphertext.data + off,
+				to_trn_tbl[ecx],
+				"Ciphertext data not as expected");
+
+		off += to_trn_tbl[ecx++];
+		buf = buf->next;
+	}
+
+	auth_tag = digest_mem;
 	TEST_ASSERT_BUFFERS_ARE_EQUAL(
 			auth_tag,
-			reference->digest.data,
-			reference->digest.len,
-			"Generated digest not as expected");
+			tdata->auth_tag.data,
+			tdata->auth_tag.len,
+			"Generated auth tag not as expected");
 
-	return TEST_SUCCESS;
+	return 0;
+}
 
+static int
+test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
+{
+	return test_authenticated_encryption_SGL(
+			&gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
 }
 
 static int
-test_authenticated_decrypt_with_esn(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
+test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
 {
-	int retval;
+	return test_authenticated_encryption_SGL(
+			&gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
+}
 
-	uint8_t *ciphertext;
-	uint8_t cipher_key[reference->cipher_key.len + 1];
-	uint8_t auth_key[reference->auth_key.len + 1];
+static int
+test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
+{
+	/* This test is not for QAT PMD */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))
+		return -ENOTSUP;
 
-	/* Create session */
-	memcpy(cipher_key, reference->cipher_key.data,
-			reference->cipher_key.len);
-	memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
+	return test_authenticated_encryption_SGL(
+			&gcm_test_case_8, OUT_OF_PLACE, 400,
+			gcm_test_case_8.plaintext.len);
+}
 
-	/* Setup Authentication Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
-	ut_params->auth_xform.auth.algo = reference->auth_algo;
-	ut_params->auth_xform.auth.key.length = reference->auth_key.len;
-	ut_params->auth_xform.auth.key.data = auth_key;
-	ut_params->auth_xform.auth.digest_length = reference->digest.len;
-	ut_params->auth_xform.next = &ut_params->cipher_xform;
+static int
+test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
+{
+	/* This test fails on OPENSSL PMD although it returns it supports SGL */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
+		return -ENOTSUP;
 
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = NULL;
-	ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
-	ut_params->cipher_xform.cipher.key.data = cipher_key;
-	ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
-	ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-	ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
-
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(
-			ts_params->session_mpool);
+	return test_authenticated_encryption_SGL(
+			&gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
+}
 
-	rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
-				ut_params->sess,
-				&ut_params->auth_xform,
-				ts_params->session_priv_mpool);
+static int
+test_authentication_verify_fail_when_data_corrupted(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return test_authentication_verify_fail_when_data_corruption(
+			ts_params, ut_params, reference, 1);
+}
 
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+static int
+test_authentication_verify_fail_when_tag_corrupted(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return test_authentication_verify_fail_when_data_corruption(
+			ts_params, ut_params, reference, 0);
+}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-	TEST_ASSERT_NOT_NULL(ut_params->ibuf,
-			"Failed to allocate input buffer in mempool");
+static int
+test_authentication_verify_GMAC_fail_when_data_corrupted(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return test_authentication_verify_GMAC_fail_when_corruption(
+			ts_params, ut_params, reference, 1);
+}
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+static int
+test_authentication_verify_GMAC_fail_when_tag_corrupted(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return test_authentication_verify_GMAC_fail_when_corruption(
+			ts_params, ut_params, reference, 0);
+}
 
-	ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			reference->ciphertext.len);
-	TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
-	memcpy(ciphertext, reference->ciphertext.data,
-			reference->ciphertext.len);
+static int
+test_authenticated_decryption_fail_when_data_corrupted(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return test_authenticated_decryption_fail_when_corruption(
+			ts_params, ut_params, reference, 1);
+}
 
-	/* Create operation */
-	retval = create_cipher_auth_verify_operation(ts_params,
-			ut_params,
-			reference);
+static int
+test_authenticated_decryption_fail_when_tag_corrupted(
+		struct crypto_testsuite_params *ts_params,
+		struct crypto_unittest_params *ut_params,
+		const struct test_crypto_vector *reference)
+{
+	return test_authenticated_decryption_fail_when_corruption(
+			ts_params, ut_params, reference, 0);
+}
 
-	if (retval < 0)
-		return retval;
+static int
+authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
+{
+	return test_authentication_verify_fail_when_data_corrupted(
+			&testsuite_params, &unittest_params,
+			&hmac_sha1_test_crypto_vector);
+}
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op);
+static int
+authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
+{
+	return test_authentication_verify_fail_when_tag_corrupted(
+			&testsuite_params, &unittest_params,
+			&hmac_sha1_test_crypto_vector);
+}
 
-	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
-	TEST_ASSERT_EQUAL(ut_params->op->status,
-			RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing passed");
+static int
+authentication_verify_AES128_GMAC_fail_data_corrupt(void)
+{
+	return test_authentication_verify_GMAC_fail_when_data_corrupted(
+			&testsuite_params, &unittest_params,
+			&aes128_gmac_test_vector);
+}
 
-	ut_params->obuf = ut_params->op->sym->m_src;
-	TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
+static int
+authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
+{
+	return test_authentication_verify_GMAC_fail_when_tag_corrupted(
+			&testsuite_params, &unittest_params,
+			&aes128_gmac_test_vector);
+}
 
-	return 0;
+static int
+auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
+{
+	return test_authenticated_decryption_fail_when_data_corrupted(
+			&testsuite_params,
+			&unittest_params,
+			&aes128cbc_hmac_sha1_test_vector);
 }
 
 static int
-create_aead_operation_SGL(enum rte_crypto_aead_operation op,
-		const struct aead_test_data *tdata,
-		void *digest_mem, uint64_t digest_phys)
+auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
 {
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
+	return test_authenticated_decryption_fail_when_tag_corrupted(
+			&testsuite_params,
+			&unittest_params,
+			&aes128cbc_hmac_sha1_test_vector);
+}
 
-	const unsigned int auth_tag_len = tdata->auth_tag.len;
-	const unsigned int iv_len = tdata->iv.len;
-	unsigned int aad_len = tdata->aad.len;
+static int
+auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
+{
+	return test_authenticated_encryt_with_esn(
+			&testsuite_params,
+			&unittest_params,
+			&aes128cbc_hmac_sha1_aad_test_vector);
+}
 
-	/* Generate Crypto op data structure */
-	ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
-			RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-	TEST_ASSERT_NOT_NULL(ut_params->op,
-		"Failed to allocate symmetric crypto operation struct");
+static int
+auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
+{
+	return test_authenticated_decrypt_with_esn(
+			&testsuite_params,
+			&unittest_params,
+			&aes128cbc_hmac_sha1_aad_test_vector);
+}
 
-	struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
+#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 
-	sym_op->aead.digest.data = digest_mem;
+/* global AESNI slave IDs for the scheduler test */
+uint8_t aesni_ids[2];
 
-	TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
-			"no room to append digest");
+static int
+test_scheduler_attach_slave_op(void)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	uint8_t sched_id = ts_params->valid_devs[0];
+	uint32_t nb_devs, i, nb_devs_attached = 0;
+	int ret;
+	char vdev_name[32];
 
-	sym_op->aead.digest.phys_addr = digest_phys;
+	/* create 2 AESNI_MB if necessary */
+	nb_devs = rte_cryptodev_device_count_by_driver(
+			rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
+	if (nb_devs < 2) {
+		for (i = nb_devs; i < 2; i++) {
+			snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
+					RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
+					i);
+			ret = rte_vdev_init(vdev_name, NULL);
 
-	if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
-		rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
-				auth_tag_len);
-		debug_hexdump(stdout, "digest:",
-				sym_op->aead.digest.data,
-				auth_tag_len);
+			TEST_ASSERT(ret == 0,
+				"Failed to create instance %u of"
+				" pmd : %s",
+				i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
+		}
 	}
 
-	/* Append aad data */
-	if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
-		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-				uint8_t *, IV_OFFSET);
-
-		/* Copy IV 1 byte after the IV pointer, according to the API */
-		rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
-
-		aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
-
-		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
-				ut_params->ibuf, aad_len);
-		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
-				"no room to prepend aad");
-		sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
-				ut_params->ibuf);
-
-		memset(sym_op->aead.aad.data, 0, aad_len);
-		/* Copy AAD 18 bytes after the AAD pointer, according to the API */
-		rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
+	/* attach 2 AESNI_MB cdevs */
+	for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
+			i++) {
+		struct rte_cryptodev_info info;
+		unsigned int session_size;
 
-		debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
-		debug_hexdump(stdout, "aad:",
-				sym_op->aead.aad.data, aad_len);
-	} else {
-		uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-				uint8_t *, IV_OFFSET);
+		rte_cryptodev_info_get(i, &info);
+		if (info.driver_id != rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
+			continue;
 
-		rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
+		session_size = rte_cryptodev_sym_get_private_session_size(i);
+		/*
+		 * Create the session mempool again, since now there are new
+		 * devices to use the mempool.
+		 */
+		if (ts_params->session_mpool) {
+			rte_mempool_free(ts_params->session_mpool);
+			ts_params->session_mpool = NULL;
+		}
+		if (ts_params->session_priv_mpool) {
+			rte_mempool_free(ts_params->session_priv_mpool);
+			ts_params->session_priv_mpool = NULL;
+		}
 
-		sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
-				ut_params->ibuf, aad_len);
-		TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
-				"no room to prepend aad");
-		sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
-				ut_params->ibuf);
+		if (info.sym.max_nb_sessions != 0 &&
+				info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
+			RTE_LOG(ERR, USER1,
+					"Device does not support "
+					"at least %u sessions\n",
+					MAX_NB_SESSIONS);
+			return TEST_FAILED;
+		}
+		/*
+		 * Create mempool with maximum number of sessions,
+		 * to include the session headers
+		 */
+		if (ts_params->session_mpool == NULL) {
+			ts_params->session_mpool =
+				rte_cryptodev_sym_session_pool_create(
+						"test_sess_mp",
+						MAX_NB_SESSIONS, 0, 0, 0,
+						SOCKET_ID_ANY);
+			TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
+					"session mempool allocation failed");
+		}
 
-		memset(sym_op->aead.aad.data, 0, aad_len);
-		rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
+		/*
+		 * Create mempool with maximum number of sessions,
+		 * to include device specific session private data
+		 */
+		if (ts_params->session_priv_mpool == NULL) {
+			ts_params->session_priv_mpool = rte_mempool_create(
+					"test_sess_mp_priv",
+					MAX_NB_SESSIONS,
+					session_size,
+					0, 0, NULL, NULL, NULL,
+					NULL, SOCKET_ID_ANY,
+					0);
 
-		debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
-		debug_hexdump(stdout, "aad:",
-				sym_op->aead.aad.data, aad_len);
-	}
+			TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
+					"session mempool allocation failed");
+		}
 
-	sym_op->aead.data.length = tdata->plaintext.len;
-	sym_op->aead.data.offset = aad_len;
+		ts_params->qp_conf.mp_session = ts_params->session_mpool;
+		ts_params->qp_conf.mp_session_private =
+				ts_params->session_priv_mpool;
+
+		ret = rte_cryptodev_scheduler_slave_attach(sched_id,
+				(uint8_t)i);
+
+		TEST_ASSERT(ret == 0,
+			"Failed to attach device %u of pmd : %s", i,
+			RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
+
+		aesni_ids[nb_devs_attached] = (uint8_t)i;
+
+		nb_devs_attached++;
+	}
 
 	return 0;
 }
 
-#define SGL_MAX_NO	16
-
 static int
-test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
-		const int oop, uint32_t fragsz, uint32_t fragsz_oop)
+test_scheduler_detach_slave_op(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
-	int retval;
-	int to_trn = 0;
-	int to_trn_tbl[SGL_MAX_NO];
-	int segs = 1;
-	unsigned int trn_data = 0;
-	uint8_t *plaintext, *ciphertext, *auth_tag;
-
-	if (fragsz > tdata->plaintext.len)
-		fragsz = tdata->plaintext.len;
-
-	uint16_t plaintext_len = fragsz;
-	uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
-
-	if (fragsz_oop > tdata->plaintext.len)
-		frag_size_oop = tdata->plaintext.len;
-
-	int ecx = 0;
-	void *digest_mem = NULL;
-
-	uint32_t prepend_len = tdata->aad.len;
-
-	if (tdata->plaintext.len % fragsz != 0) {
-		if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
-			return 1;
-	}	else {
-		if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
-			return 1;
-	}
+	uint8_t sched_id = ts_params->valid_devs[0];
+	uint32_t i;
+	int ret;
 
-	/*
-	 * For out-op-place we need to alloc another mbuf
-	 */
-	if (oop) {
-		ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-		rte_pktmbuf_append(ut_params->obuf,
-				frag_size_oop + prepend_len);
-		buf_oop = ut_params->obuf;
+	for (i = 0; i < 2; i++) {
+		ret = rte_cryptodev_scheduler_slave_detach(sched_id,
+				aesni_ids[i]);
+		TEST_ASSERT(ret == 0,
+			"Failed to detach device %u", aesni_ids[i]);
 	}
 
-	/* Create AEAD session */
-	retval = create_aead_session(ts_params->valid_devs[0],
-			tdata->algo,
-			RTE_CRYPTO_AEAD_OP_ENCRYPT,
-			tdata->key.data, tdata->key.len,
-			tdata->aad.len, tdata->auth_tag.len,
-			tdata->iv.len);
-	if (retval < 0)
-		return retval;
+	return 0;
+}
 
-	ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+static int
+test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
+{
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+	uint8_t sched_id = ts_params->valid_devs[0];
 
-	/* clear mbuf payload */
-	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
-			rte_pktmbuf_tailroom(ut_params->ibuf));
+	/* set mode */
+	return rte_cryptodev_scheduler_mode_set(sched_id,
+		scheduler_mode);
+}
 
-	plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-			plaintext_len);
+static int
+test_scheduler_mode_roundrobin_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
+			0, "Failed to set roundrobin mode");
+	return 0;
+}
 
-	memcpy(plaintext, tdata->plaintext.data, plaintext_len);
+static int
+test_scheduler_mode_multicore_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
+			0, "Failed to set multicore mode");
 
-	trn_data += plaintext_len;
+	return 0;
+}
 
-	buf = ut_params->ibuf;
+static int
+test_scheduler_mode_failover_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
+			0, "Failed to set failover mode");
 
-	/*
-	 * Loop until no more fragments
-	 */
+	return 0;
+}
 
-	while (trn_data < tdata->plaintext.len) {
-		++segs;
-		to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
-				(tdata->plaintext.len - trn_data) : fragsz;
+static int
+test_scheduler_mode_pkt_size_distr_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
+			0, "Failed to set pktsize mode");
 
-		to_trn_tbl[ecx++] = to_trn;
+	return 0;
+}
 
-		buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
-		buf = buf->next;
+static struct unit_test_suite cryptodev_scheduler_testsuite  = {
+	.suite_name = "Crypto Device Scheduler Unit Test Suite",
+	.setup = testsuite_setup,
+	.teardown = testsuite_teardown,
+	.unit_test_cases = {
+		/* Multi Core */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
 
-		memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
-				rte_pktmbuf_tailroom(buf));
+		/* Round Robin */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
 
-		/* OOP */
-		if (oop && !fragsz_oop) {
-			buf_last_oop = buf_oop->next =
-					rte_pktmbuf_alloc(ts_params->mbuf_pool);
-			buf_oop = buf_oop->next;
-			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
-					0, rte_pktmbuf_tailroom(buf_oop));
-			rte_pktmbuf_append(buf_oop, to_trn);
-		}
+		/* Fail over */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
 
-		plaintext = (uint8_t *)rte_pktmbuf_append(buf,
-				to_trn);
+		/* PKT SIZE */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+		TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
 
-		memcpy(plaintext, tdata->plaintext.data + trn_data,
-				to_trn);
-		trn_data += to_trn;
-		if (trn_data  == tdata->plaintext.len) {
-			if (oop) {
-				if (!fragsz_oop)
-					digest_mem = rte_pktmbuf_append(buf_oop,
-						tdata->auth_tag.len);
-			} else
-				digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
-					tdata->auth_tag.len);
-		}
+		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
+};
 
-	uint64_t digest_phys = 0;
-
-	ut_params->ibuf->nb_segs = segs;
-
-	segs = 1;
-	if (fragsz_oop && oop) {
-		to_trn = 0;
-		ecx = 0;
-
-		if (frag_size_oop == tdata->plaintext.len) {
-			digest_mem = rte_pktmbuf_append(ut_params->obuf,
-				tdata->auth_tag.len);
-
-			digest_phys = rte_pktmbuf_iova_offset(
-					ut_params->obuf,
-					tdata->plaintext.len + prepend_len);
-		}
-
-		trn_data = frag_size_oop;
-		while (trn_data < tdata->plaintext.len) {
-			++segs;
-			to_trn =
-				(tdata->plaintext.len - trn_data <
-						frag_size_oop) ?
-				(tdata->plaintext.len - trn_data) :
-						frag_size_oop;
+#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 
-			to_trn_tbl[ecx++] = to_trn;
-
-			buf_last_oop = buf_oop->next =
-					rte_pktmbuf_alloc(ts_params->mbuf_pool);
-			buf_oop = buf_oop->next;
-			memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
-					0, rte_pktmbuf_tailroom(buf_oop));
-			rte_pktmbuf_append(buf_oop, to_trn);
-
-			trn_data += to_trn;
-
-			if (trn_data  == tdata->plaintext.len) {
-				digest_mem = rte_pktmbuf_append(buf_oop,
-					tdata->auth_tag.len);
-			}
-		}
-
-		ut_params->obuf->nb_segs = segs;
-	}
-
-	/*
-	 * Place digest at the end of the last buffer
-	 */
-	if (!digest_phys)
-		digest_phys = rte_pktmbuf_iova(buf) + to_trn;
-	if (oop && buf_last_oop)
-		digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
-
-	if (!digest_mem && !oop) {
-		digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-				+ tdata->auth_tag.len);
-		digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
-				tdata->plaintext.len);
-	}
-
-	/* Create AEAD operation */
-	retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
-			tdata, digest_mem, digest_phys);
-
-	if (retval < 0)
-		return retval;
-
-	rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
-
-	ut_params->op->sym->m_src = ut_params->ibuf;
-	if (oop)
-		ut_params->op->sym->m_dst = ut_params->obuf;
-
-	/* Process crypto operation */
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
-
-	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
-			"crypto op processing failed");
-
-
-	ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
-			uint8_t *, prepend_len);
-	if (oop) {
-		ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
-				uint8_t *, prepend_len);
-	}
-
-	if (fragsz_oop)
-		fragsz = fragsz_oop;
-
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			ciphertext,
-			tdata->ciphertext.data,
-			fragsz,
-			"Ciphertext data not as expected");
-
-	buf = ut_params->op->sym->m_src->next;
-	if (oop)
-		buf = ut_params->op->sym->m_dst->next;
-
-	unsigned int off = fragsz;
-
-	ecx = 0;
-	while (buf) {
-		ciphertext = rte_pktmbuf_mtod(buf,
-				uint8_t *);
-
-		TEST_ASSERT_BUFFERS_ARE_EQUAL(
-				ciphertext,
-				tdata->ciphertext.data + off,
-				to_trn_tbl[ecx],
-				"Ciphertext data not as expected");
-
-		off += to_trn_tbl[ecx++];
-		buf = buf->next;
-	}
-
-	auth_tag = digest_mem;
-	TEST_ASSERT_BUFFERS_ARE_EQUAL(
-			auth_tag,
-			tdata->auth_tag.data,
-			tdata->auth_tag.len,
-			"Generated auth tag not as expected");
-
-	return 0;
-}
-
-static int
-test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
-{
-	return test_authenticated_encryption_SGL(
-			&gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
-}
-
-static int
-test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
-{
-	return test_authenticated_encryption_SGL(
-			&gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
-}
-
-static int
-test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
-{
-	return test_authenticated_encryption_SGL(
-			&gcm_test_case_8, OUT_OF_PLACE, 400,
-			gcm_test_case_8.plaintext.len);
-}
-
-static int
-test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
-{
-
-	return test_authenticated_encryption_SGL(
-			&gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
-}
-
-static int
-test_authentication_verify_fail_when_data_corrupted(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return test_authentication_verify_fail_when_data_corruption(
-			ts_params, ut_params, reference, 1);
-}
-
-static int
-test_authentication_verify_fail_when_tag_corrupted(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return test_authentication_verify_fail_when_data_corruption(
-			ts_params, ut_params, reference, 0);
-}
-
-static int
-test_authentication_verify_GMAC_fail_when_data_corrupted(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return test_authentication_verify_GMAC_fail_when_corruption(
-			ts_params, ut_params, reference, 1);
-}
-
-static int
-test_authentication_verify_GMAC_fail_when_tag_corrupted(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return test_authentication_verify_GMAC_fail_when_corruption(
-			ts_params, ut_params, reference, 0);
-}
-
-static int
-test_authenticated_decryption_fail_when_data_corrupted(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return test_authenticated_decryption_fail_when_corruption(
-			ts_params, ut_params, reference, 1);
-}
-
-static int
-test_authenticated_decryption_fail_when_tag_corrupted(
-		struct crypto_testsuite_params *ts_params,
-		struct crypto_unittest_params *ut_params,
-		const struct test_crypto_vector *reference)
-{
-	return test_authenticated_decryption_fail_when_corruption(
-			ts_params, ut_params, reference, 0);
-}
-
-static int
-authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
-{
-	return test_authentication_verify_fail_when_data_corrupted(
-			&testsuite_params, &unittest_params,
-			&hmac_sha1_test_crypto_vector);
-}
-
-static int
-authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
-{
-	return test_authentication_verify_fail_when_tag_corrupted(
-			&testsuite_params, &unittest_params,
-			&hmac_sha1_test_crypto_vector);
-}
-
-static int
-authentication_verify_AES128_GMAC_fail_data_corrupt(void)
-{
-	return test_authentication_verify_GMAC_fail_when_data_corrupted(
-			&testsuite_params, &unittest_params,
-			&aes128_gmac_test_vector);
-}
-
-static int
-authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
-{
-	return test_authentication_verify_GMAC_fail_when_tag_corrupted(
-			&testsuite_params, &unittest_params,
-			&aes128_gmac_test_vector);
-}
-
-static int
-auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
-{
-	return test_authenticated_decryption_fail_when_data_corrupted(
-			&testsuite_params,
-			&unittest_params,
-			&aes128cbc_hmac_sha1_test_vector);
-}
-
-static int
-auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
-{
-	return test_authenticated_decryption_fail_when_tag_corrupted(
-			&testsuite_params,
-			&unittest_params,
-			&aes128cbc_hmac_sha1_test_vector);
-}
-
-static int
-auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
-{
-	return test_authenticated_encryt_with_esn(
-			&testsuite_params,
-			&unittest_params,
-			&aes128cbc_hmac_sha1_aad_test_vector);
-}
-
-static int
-auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
-{
-	return test_authenticated_decrypt_with_esn(
-			&testsuite_params,
-			&unittest_params,
-			&aes128cbc_hmac_sha1_aad_test_vector);
-}
-
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
-
-/* global AESNI slave IDs for the scheduler test */
-uint8_t aesni_ids[2];
-
-static int
-test_scheduler_attach_slave_op(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	uint8_t sched_id = ts_params->valid_devs[0];
-	uint32_t nb_devs, i, nb_devs_attached = 0;
-	int ret;
-	char vdev_name[32];
-
-	/* create 2 AESNI_MB if necessary */
-	nb_devs = rte_cryptodev_device_count_by_driver(
-			rte_cryptodev_driver_id_get(
-			RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
-	if (nb_devs < 2) {
-		for (i = nb_devs; i < 2; i++) {
-			snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
-					RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
-					i);
-			ret = rte_vdev_init(vdev_name, NULL);
-
-			TEST_ASSERT(ret == 0,
-				"Failed to create instance %u of"
-				" pmd : %s",
-				i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
-		}
-	}
-
-	/* attach 2 AESNI_MB cdevs */
-	for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
-			i++) {
-		struct rte_cryptodev_info info;
-		unsigned int session_size;
-
-		rte_cryptodev_info_get(i, &info);
-		if (info.driver_id != rte_cryptodev_driver_id_get(
-				RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
-			continue;
-
-		session_size = rte_cryptodev_sym_get_private_session_size(i);
-		/*
-		 * Create the session mempool again, since now there are new devices
-		 * to use the mempool.
-		 */
-		if (ts_params->session_mpool) {
-			rte_mempool_free(ts_params->session_mpool);
-			ts_params->session_mpool = NULL;
-		}
-		if (ts_params->session_priv_mpool) {
-			rte_mempool_free(ts_params->session_priv_mpool);
-			ts_params->session_priv_mpool = NULL;
-		}
-
-		if (info.sym.max_nb_sessions != 0 &&
-				info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
-			RTE_LOG(ERR, USER1,
-					"Device does not support "
-					"at least %u sessions\n",
-					MAX_NB_SESSIONS);
-			return TEST_FAILED;
-		}
-		/*
-		 * Create mempool with maximum number of sessions,
-		 * to include the session headers
-		 */
-		if (ts_params->session_mpool == NULL) {
-			ts_params->session_mpool =
-				rte_cryptodev_sym_session_pool_create(
-						"test_sess_mp",
-						MAX_NB_SESSIONS, 0, 0, 0,
-						SOCKET_ID_ANY);
-			TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
-					"session mempool allocation failed");
-		}
-
-		/*
-		 * Create mempool with maximum number of sessions,
-		 * to include device specific session private data
-		 */
-		if (ts_params->session_priv_mpool == NULL) {
-			ts_params->session_priv_mpool = rte_mempool_create(
-					"test_sess_mp_priv",
-					MAX_NB_SESSIONS,
-					session_size,
-					0, 0, NULL, NULL, NULL,
-					NULL, SOCKET_ID_ANY,
-					0);
-
-			TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
-					"session mempool allocation failed");
-		}
-
-		ts_params->qp_conf.mp_session = ts_params->session_mpool;
-		ts_params->qp_conf.mp_session_private =
-				ts_params->session_priv_mpool;
-
-		ret = rte_cryptodev_scheduler_slave_attach(sched_id,
-				(uint8_t)i);
-
-		TEST_ASSERT(ret == 0,
-			"Failed to attach device %u of pmd : %s", i,
-			RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
-
-		aesni_ids[nb_devs_attached] = (uint8_t)i;
-
-		nb_devs_attached++;
-	}
-
-	return 0;
-}
-
-static int
-test_scheduler_detach_slave_op(void)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	uint8_t sched_id = ts_params->valid_devs[0];
-	uint32_t i;
-	int ret;
-
-	for (i = 0; i < 2; i++) {
-		ret = rte_cryptodev_scheduler_slave_detach(sched_id,
-				aesni_ids[i]);
-		TEST_ASSERT(ret == 0,
-			"Failed to detach device %u", aesni_ids[i]);
-	}
-
-	return 0;
-}
-
-static int
-test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
-{
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	uint8_t sched_id = ts_params->valid_devs[0];
-	/* set mode */
-	return rte_cryptodev_scheduler_mode_set(sched_id,
-		scheduler_mode);
-}
-
-static int
-test_scheduler_mode_roundrobin_op(void)
-{
-	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
-			0, "Failed to set roundrobin mode");
-	return 0;
-
-}
-
-static int
-test_scheduler_mode_multicore_op(void)
-{
-	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
-			0, "Failed to set multicore mode");
-
-	return 0;
-}
-
-static int
-test_scheduler_mode_failover_op(void)
-{
-	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
-			0, "Failed to set failover mode");
-
-	return 0;
-}
-
-static int
-test_scheduler_mode_pkt_size_distr_op(void)
-{
-	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
-			0, "Failed to set pktsize mode");
-
-	return 0;
-}
-
-static struct unit_test_suite cryptodev_scheduler_testsuite  = {
-	.suite_name = "Crypto Device Scheduler Unit Test Suite",
-	.setup = testsuite_setup,
-	.teardown = testsuite_teardown,
-	.unit_test_cases = {
-		/* Multi Core */
-		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_AES_chain_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_AES_cipheronly_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_authonly_scheduler_all),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
-
-		/* Round Robin */
-		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_AES_chain_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_AES_cipheronly_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_authonly_scheduler_all),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
-
-		/* Fail over */
-		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_AES_chain_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_AES_cipheronly_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_authonly_scheduler_all),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
-
-		/* PKT SIZE */
-		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_AES_chain_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_AES_cipheronly_scheduler_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-					test_authonly_scheduler_all),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
-
-		TEST_CASES_END() /**< NULL terminate unit test array */
-	}
-};
-
-#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
-
-static struct unit_test_suite cryptodev_qat_testsuite  = {
-	.suite_name = "Crypto QAT Unit Test Suite",
-	.setup = testsuite_setup,
-	.teardown = testsuite_teardown,
-	.unit_test_cases = {
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_device_configure_invalid_dev_id),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_device_configure_invalid_queue_pair_ids),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_queue_pair_descriptor_setup),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_multi_session),
-
-		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_AES_cipheronly_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_3DES_cipheronly_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_DES_cipheronly_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_AES_docsis_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_DES_docsis_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
-		TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
-
-		/** AES CCM Authenticated Encryption 128 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_encryption_test_case_128_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_encryption_test_case_128_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_encryption_test_case_128_3),
-
-		/** AES CCM Authenticated Decryption 128 bits key*/
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_decryption_test_case_128_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_decryption_test_case_128_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_decryption_test_case_128_3),
-
-		/** AES GCM Authenticated Encryption */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_7),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_8),
-
-		/** AES GCM Authenticated Decryption */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_7),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_8),
-
-		/** AES GCM Authenticated Encryption 192 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_7),
-
-		/** AES GCM Authenticated Decryption 192 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_7),
-
-		/** AES GCM Authenticated Encryption 256 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_7),
-
-		/** AES GCM Authenticated Decryption 256 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_7),
-
-		/** AES GMAC Authentication */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_verify_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_verify_test_case_3),
-
-		/** SNOW 3G encrypt only (UEA2) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_encryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_encryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_encryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_encryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_encryption_test_case_5),
-
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_encryption_test_case_1_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_test_case_1_oop),
-
-		/** SNOW 3G generate auth, then encrypt (UEA2) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_test_case_2_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_part_digest_enc),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_part_digest_enc_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_test_case_3_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_test_case_3_oop_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_part_digest_enc_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
-
-		/** SNOW 3G decrypt (UEA2), then verify auth */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_test_case_2_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_part_digest_enc),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_part_digest_enc_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_test_case_3_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
-
-		/** SNOW 3G decrypt only (UEA2) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_decryption_with_digest_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_hash_generate_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_hash_generate_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_hash_generate_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_hash_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_hash_verify_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_hash_verify_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_cipher_auth_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_snow3g_auth_cipher_with_digest_test_case_1),
-
-		/** ZUC encrypt only (EEA3) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_encryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_encryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_encryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_encryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_encryption_test_case_5),
-
-		/** ZUC authenticate (EIA3) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_hash_generate_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_hash_generate_test_case_7),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_hash_generate_test_case_8),
-
-		/** ZUC alg-chain (EEA3/EIA3) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_cipher_auth_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_cipher_auth_test_case_2),
-
-		/** ZUC generate auth, then encrypt (EEA3) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_test_case_1_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_test_case_1_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_test_case_1_oop_sgl),
-
-		/** ZUC decrypt (EEA3), then verify auth */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_verify_test_case_1_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_verify_test_case_1_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
-
-		/** HMAC_MD5 Authentication */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_MD5_HMAC_generate_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_MD5_HMAC_verify_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_MD5_HMAC_generate_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_MD5_HMAC_verify_case_2),
-
-		/** NULL algo tests done in chain_all,
-		 * cipheronly and authonly suites
-		 */
-
-		/** KASUMI tests */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_generate_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_generate_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_generate_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_generate_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_generate_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_generate_test_case_6),
-
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_verify_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_verify_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_verify_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_hash_verify_test_case_5),
-
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_encryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_encryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_cipher_auth_test_case_1),
-
-		/** KASUMI generate auth, then encrypt (F8) */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_test_case_2_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_test_case_2_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_test_case_2_oop_sgl),
-
-		/** KASUMI decrypt (F8), then verify auth */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_verify_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_verify_test_case_2_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_verify_test_case_2_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
-
-		/** Negative tests */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			authentication_verify_HMAC_SHA1_fail_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			authentication_verify_HMAC_SHA1_fail_tag_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_fail_iv_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_fail_in_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_fail_out_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_fail_aad_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_fail_tag_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_fail_iv_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_fail_in_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_fail_out_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_fail_aad_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_fail_tag_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			authentication_verify_AES128_GMAC_fail_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			authentication_verify_AES128_GMAC_fail_tag_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
-
-		/** Mixed CIPHER + HASH algorithms */
-		/** AUTH AES CMAC + CIPHER AES CTR */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_aes_cmac_aes_ctr_digest_enc_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-		       test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-		       test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-		   test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
-
-		/** AUTH ZUC + CIPHER SNOW3G */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_zuc_cipher_snow_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_zuc_cipher_snow_test_case_1),
-		/** AUTH AES CMAC + CIPHER SNOW3G */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_aes_cmac_cipher_snow_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_aes_cmac_cipher_snow_test_case_1),
-		/** AUTH ZUC + CIPHER AES CTR */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_zuc_cipher_aes_ctr_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
-		/** AUTH SNOW3G + CIPHER AES CTR */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_snow_cipher_aes_ctr_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_snow_cipher_aes_ctr_test_case_1),
-		/** AUTH SNOW3G + CIPHER ZUC */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_snow_cipher_zuc_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_snow_cipher_zuc_test_case_1),
-		/** AUTH AES CMAC + CIPHER ZUC */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_aes_cmac_cipher_zuc_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
-
-		/** AUTH NULL + CIPHER SNOW3G */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_null_cipher_snow_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_null_cipher_snow_test_case_1),
-		/** AUTH NULL + CIPHER ZUC */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_null_cipher_zuc_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_null_cipher_zuc_test_case_1),
-		/** AUTH SNOW3G + CIPHER NULL */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_snow_cipher_null_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_snow_cipher_null_test_case_1),
-		/** AUTH ZUC + CIPHER NULL */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_zuc_cipher_null_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_zuc_cipher_null_test_case_1),
-		/** AUTH NULL + CIPHER AES CTR */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_null_cipher_aes_ctr_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_null_cipher_aes_ctr_test_case_1),
-		/** AUTH AES CMAC + CIPHER NULL */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_auth_aes_cmac_cipher_null_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_verify_auth_aes_cmac_cipher_null_test_case_1),
-
-		TEST_CASES_END() /**< NULL terminate unit test array */
-	}
-};
-
-static struct unit_test_suite cryptodev_virtio_testsuite = {
-	.suite_name = "Crypto VIRTIO Unit Test Suite",
-	.setup = testsuite_setup,
-	.teardown = testsuite_teardown,
-	.unit_test_cases = {
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_AES_cipheronly_virtio_all),
-
-		TEST_CASES_END() /**< NULL terminate unit test array */
-	}
-};
-
-static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
-	.suite_name = "Crypto Device AESNI MB Unit Test Suite",
-	.setup = testsuite_setup,
-	.teardown = testsuite_teardown,
-	.unit_test_cases = {
-#if IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0)
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_7),
-
-		/** AES GCM Authenticated Decryption */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_7),
-
-		/** AES GCM Authenticated Encryption 192 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_7),
-
-		/** AES GCM Authenticated Decryption 192 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_7),
-
-		/** AES GCM Authenticated Encryption 256 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_7),
-
-		/** AES GCM Authenticated Decryption 256 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_256_7),
-
-		/** AES GCM Authenticated Encryption big aad size */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_aad_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_aad_2),
-
-		/** AES GCM Authenticated Decryption big aad size */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_aad_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_aad_2),
-
-		/** Session-less tests */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
-
-		/** AES GMAC Authentication */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_verify_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_verify_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GMAC_authentication_verify_test_case_3),
-#endif /* IMB_VERSION_NUM >= IMB_VERSION(0, 51, 0) */
-
-		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_DES_cipheronly_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_DES_docsis_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-						test_3DES_cipheronly_mb_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_encryption_test_case_128_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_decryption_test_case_128_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_encryption_test_case_128_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_decryption_test_case_128_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_encryption_test_case_128_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_CCM_authenticated_decryption_test_case_128_3),
-
-		TEST_CASES_END() /**< NULL terminate unit test array */
-	}
-};
-
-static struct unit_test_suite cryptodev_openssl_testsuite  = {
-	.suite_name = "Crypto Device OPENSSL Unit Test Suite",
+static struct unit_test_suite cryptodev_testsuite  = {
+	.suite_name = "Crypto Unit Test Suite",
 	.setup = testsuite_setup,
 	.teardown = testsuite_teardown,
 	.unit_test_cases = {
-		TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_multi_session_random_usage),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_AES_chain_openssl_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_AES_cipheronly_openssl_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_3DES_chain_openssl_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_3DES_cipheronly_openssl_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_DES_cipheronly_openssl_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_DES_docsis_openssl_all),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_authonly_openssl_all),
-
-		/** AES GCM Authenticated Encryption */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_encryption_test_case_7),
-
-		/** AES GCM Authenticated Decryption */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_authenticated_decryption_test_case_7),
-
-
-		/** AES GCM Authenticated Encryption 192 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_3),
 		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_192_7),
-
-		/** AES GCM Authenticated Decryption 192 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_2),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_3),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_4),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_5),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_6),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_decryption_test_case_192_7),
-
-		/** AES GCM Authenticated Encryption 256 bits key */
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_test_case_256_1),
-		TEST_CASE_ST(ut_setup, ut_teardown,
-			test_AES_GCM_auth_encryption_