test/security: check capabilities get

[dpdk.git] / app / test / test_cryptodev.c

diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index d406ce4..cdb8408 100644 (file)
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2015-2019 Intel Corporation
+ * Copyright(c) 2015-2020 Intel Corporation
  */
 
 #include <time.h>
@@ -52,6 +52,9 @@
 
 static int gbl_driver_id;
 
+static enum rte_security_session_action_type gbl_action_type =
+       RTE_SECURITY_ACTION_TYPE_NONE;
+
 struct crypto_testsuite_params {
        struct rte_mempool *mbuf_pool;
        struct rte_mempool *large_mbuf_pool;
@@ -139,9 +142,99 @@ ceil_byte_length(uint32_t num_bits)
                return (num_bits >> 3);
 }
 
+static void
+process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
+{
+       int32_t n, st;
+       void *iv;
+       struct rte_crypto_sym_op *sop;
+       union rte_crypto_sym_ofs ofs;
+       struct rte_crypto_sgl sgl;
+       struct rte_crypto_sym_vec symvec;
+       struct rte_crypto_vec vec[UINT8_MAX];
+
+       sop = op->sym;
+
+       n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
+               sop->aead.data.length, vec, RTE_DIM(vec));
+
+       if (n < 0 || n != sop->m_src->nb_segs) {
+               op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+               return;
+       }
+
+       sgl.vec = vec;
+       sgl.num = n;
+       symvec.sgl = &sgl;
+       iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
+       symvec.iv = &iv;
+       symvec.aad = (void **)&sop->aead.aad.data;
+       symvec.digest = (void **)&sop->aead.digest.data;
+       symvec.status = &st;
+       symvec.num = 1;
+
+       ofs.raw = 0;
+
+       n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
+               &symvec);
+
+       if (n != 1)
+               op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
+       else
+               op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+}
+
+static void
+process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
+{
+       int32_t n, st;
+       void *iv;
+       struct rte_crypto_sym_op *sop;
+       union rte_crypto_sym_ofs ofs;
+       struct rte_crypto_sgl sgl;
+       struct rte_crypto_sym_vec symvec;
+       struct rte_crypto_vec vec[UINT8_MAX];
+
+       sop = op->sym;
+
+       n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
+               sop->auth.data.length, vec, RTE_DIM(vec));
+
+       if (n < 0 || n != sop->m_src->nb_segs) {
+               op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+               return;
+       }
+
+       sgl.vec = vec;
+       sgl.num = n;
+       symvec.sgl = &sgl;
+       iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
+       symvec.iv = &iv;
+       symvec.aad = (void **)&sop->aead.aad.data;
+       symvec.digest = (void **)&sop->auth.digest.data;
+       symvec.status = &st;
+       symvec.num = 1;
+
+       ofs.raw = 0;
+       ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
+       ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
+               (sop->cipher.data.offset + sop->cipher.data.length);
+
+       n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
+               &symvec);
+
+       if (n != 1)
+               op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
+       else
+               op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
+}
+
 static struct rte_crypto_op *
 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 {
+
+       RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
+
        if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
                RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
                return NULL;
@@ -674,6 +767,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]);
 
@@ -745,6 +845,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]);
 
@@ -1353,6 +1458,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);
@@ -1422,8 +1540,14 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
        sym_op->cipher.data.length = QUOTE_512_BYTES;
 
        /* Process crypto operation */
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-                       ut_params->op), "failed to process sym crypto op");
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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");
@@ -1573,8 +1697,14 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
        sym_op->cipher.data.length = QUOTE_512_BYTES;
 
        /* Process crypto operation */
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-                       ut_params->op), "failed to process sym crypto op");
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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");
@@ -2333,6 +2463,20 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
        unsigned plaintext_len;
        uint8_t *plaintext;
 
+       /* 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;
+
+       /* 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;
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
                        tdata->key.data, tdata->key.len,
@@ -2393,6 +2537,20 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
        unsigned plaintext_len;
        uint8_t *plaintext;
 
+       /* 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;
+
+       /* 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;
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
                                tdata->key.data, tdata->key.len,
@@ -2453,6 +2611,14 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
        unsigned plaintext_len;
        uint8_t *plaintext;
 
+       /* 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;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
                        tdata->key.data, tdata->key.len,
@@ -2485,8 +2651,13 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
        if (retval < 0)
                return retval;
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-                               ut_params->op);
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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 *)
@@ -2513,6 +2684,14 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
        unsigned plaintext_len;
        uint8_t *plaintext;
 
+       /* 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;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
                                tdata->key.data, tdata->key.len,
@@ -2712,6 +2891,14 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
        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_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_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -2784,6 +2971,14 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 
        struct rte_cryptodev_info dev_info;
 
+       /* 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);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -2862,6 +3057,14 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        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_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_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -2935,6 +3138,14 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 
        struct rte_cryptodev_info dev_info;
 
+       /* 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);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -3012,6 +3223,14 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        unsigned ciphertext_pad_len;
        unsigned ciphertext_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;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3081,6 +3300,14 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        unsigned ciphertext_pad_len;
        unsigned ciphertext_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;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3148,6 +3375,14 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
        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_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,
@@ -3214,6 +3449,14 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        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_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,
@@ -3289,6 +3532,14 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
 
        struct rte_cryptodev_info dev_info;
 
+       /* 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;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -3390,6 +3641,19 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        uint8_t extra_offset = 4;
        uint8_t *expected_ciphertext_shifted;
 
+       /* 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,
@@ -3481,6 +3745,14 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
        unsigned ciphertext_pad_len;
        unsigned ciphertext_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_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,
@@ -3544,6 +3816,14 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        unsigned ciphertext_pad_len;
        unsigned ciphertext_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_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,
@@ -3704,6 +3984,19 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
        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_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,
@@ -3791,6 +4084,19 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 
        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;
@@ -3955,6 +4261,19 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 
        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;
@@ -4135,6 +4454,19 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
 
        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;
@@ -4301,6 +4633,19 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
 
        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;
@@ -4476,6 +4821,19 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
        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],
@@ -4730,6 +5088,12 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
 
        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;
@@ -4781,7 +5145,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
        ut_params->digest,
        tdata->digest.data,
-       DIGEST_BYTE_LENGTH_KASUMI_F9,
+       tdata->digest.len,
        "ZUC Generated auth tag not as expected");
 
        return 0;
@@ -4817,11 +5181,9 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata,
 
        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;
-               }
+       if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+               printf("Device doesn't support digest encrypted.\n");
+               return -ENOTSUP;
        }
 
        /* Create ZUC session */
@@ -5671,6 +6033,11 @@ test_zuc_hash_generate_test_case_6(void)
 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;
+
        return test_zuc_authentication(&zuc_test_case_auth_2080b);
 }
 
@@ -5695,6 +6062,11 @@ test_zuc_cipher_auth_test_case_2(void)
 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;
+
        return test_zuc_auth_cipher(
                &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
 }
@@ -5796,11 +6168,9 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
 
        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;
-               }
+       if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+               printf("Device doesn't support digest encrypted.\n");
+               return -ENOTSUP;
        }
 
        /* Create the session */
@@ -6534,9 +6904,15 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
                                uint8_t *, IV_OFFSET);
 
-               rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
-               debug_hexdump(stdout, "iv:", iv_ptr,
-                       tdata->iv.len);
+               if (tdata->iv.len == 0) {
+                       rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
+                       debug_hexdump(stdout, "iv:", iv_ptr,
+                               AES_GCM_J0_LENGTH);
+               } else {
+                       rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
+                       debug_hexdump(stdout, "iv:", iv_ptr,
+                               tdata->iv.len);
+               }
        }
 
        /* Append plaintext/ciphertext */
@@ -6631,6 +7007,20 @@ test_authenticated_encryption(const struct aead_test_data *tdata)
        uint16_t plaintext_pad_len;
        uint32_t i;
 
+       /* 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;
+
        /* Create AEAD session */
        retval = create_aead_session(ts_params->valid_devs[0],
                        tdata->algo,
@@ -6663,7 +7053,11 @@ test_authenticated_encryption(const struct aead_test_data *tdata)
        ut_params->op->sym->m_src = ut_params->ibuf;
 
        /* Process crypto operation */
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
+       else
+               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,
@@ -6722,6 +7116,18 @@ test_pdcp_proto(int i, int oop,
        struct crypto_unittest_params *ut_params = &unittest_params;
        uint8_t *plaintext;
        int ret = TEST_SUCCESS;
+       struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+                               rte_cryptodev_get_sec_ctx(
+                               ts_params->valid_devs[0]);
+
+       /* Verify the capabilities */
+       struct rte_security_capability_idx sec_cap_idx;
+
+       sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+       sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
+       sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
+       if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
+               return -ENOTSUP;
 
        /* Generate test mbuf data */
        ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -6784,10 +7190,6 @@ test_pdcp_proto(int i, int oop,
                .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);
@@ -6888,9 +7290,21 @@ test_pdcp_proto_SGL(int i, int oop,
        int to_trn_tbl[16];
        int segs = 1;
        unsigned int trn_data = 0;
+       struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+                               rte_cryptodev_get_sec_ctx(
+                               ts_params->valid_devs[0]);
 
-       if (fragsz > input_vec_len)
-               fragsz = input_vec_len;
+       /* Verify the capabilities */
+       struct rte_security_capability_idx sec_cap_idx;
+
+       sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
+       sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
+       sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
+       if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
+               return -ENOTSUP;
+
+       if (fragsz > input_vec_len)
+               fragsz = input_vec_len;
 
        uint16_t plaintext_len = fragsz;
        uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
@@ -7033,10 +7447,6 @@ test_pdcp_proto_SGL(int i, int oop,
                .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);
@@ -7327,6 +7737,12 @@ test_AES_GCM_authenticated_encryption_test_case_8(void)
        return test_authenticated_encryption(&gcm_test_case_8);
 }
 
+static int
+test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
+{
+       return test_authenticated_encryption(&gcm_J0_test_case_1);
+}
+
 static int
 test_AES_GCM_auth_encryption_test_case_192_1(void)
 {
@@ -7433,6 +7849,8 @@ test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
        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;
 }
@@ -7447,6 +7865,8 @@ test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
        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;
 }
@@ -7461,6 +7881,8 @@ test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
        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;
 }
@@ -7475,6 +7897,8 @@ test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
        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;
 }
@@ -7492,6 +7916,8 @@ test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
        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;
 }
@@ -7506,6 +7932,8 @@ test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
        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;
 }
@@ -7520,6 +7948,20 @@ test_authenticated_decryption(const struct aead_test_data *tdata)
        uint8_t *plaintext;
        uint32_t i;
 
+       /* 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;
+
        /* Create AEAD session */
        retval = create_aead_session(ts_params->valid_devs[0],
                        tdata->algo,
@@ -7552,7 +7994,11 @@ test_authenticated_decryption(const struct aead_test_data *tdata)
        ut_params->op->sym->m_src = ut_params->ibuf;
 
        /* Process crypto operation */
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
+       else
+               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,
@@ -7630,6 +8076,12 @@ test_AES_GCM_authenticated_decryption_test_case_8(void)
        return test_authenticated_decryption(&gcm_test_case_8);
 }
 
+static int
+test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
+{
+       return test_authenticated_decryption(&gcm_J0_test_case_1);
+}
+
 static int
 test_AES_GCM_auth_decryption_test_case_192_1(void)
 {
@@ -7735,6 +8187,8 @@ test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
        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;
 }
@@ -7749,6 +8203,8 @@ test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
        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;
 }
@@ -7762,6 +8218,8 @@ test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
        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;
 }
@@ -7775,6 +8233,8 @@ test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
        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;
 }
@@ -7791,6 +8251,8 @@ test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
        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;
 }
@@ -7804,6 +8266,8 @@ test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
        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;
 }
@@ -7818,6 +8282,18 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata)
        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;
+
+       /* not supported with CPU crypto */
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create AEAD session */
        retval = create_aead_session(ts_params->valid_devs[0],
                        tdata->algo,
@@ -7895,6 +8371,18 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata)
        int retval;
        uint8_t *plaintext;
 
+       /* 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;
+
+       /* not supported with CPU crypto */
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create AEAD session */
        retval = create_aead_session(ts_params->valid_devs[0],
                        tdata->algo,
@@ -7967,6 +8455,25 @@ test_authenticated_encryption_sessionless(
        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;
+
+       /* not supported with CPU crypto */
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               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 */
@@ -8048,6 +8555,25 @@ test_authenticated_decryption_sessionless(
        uint8_t *plaintext;
        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;
+
+       /* not supported with CPU crypto */
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               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;
+
        /* alloc mbuf and set payload */
        ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
 
@@ -8226,6 +8752,22 @@ test_stats(void)
        struct rte_cryptodev *dev;
        cryptodev_stats_get_t temp_pfn;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
+       /* 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;
+
        rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
        TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
                        &stats) == -ENODEV),
@@ -8360,6 +8902,14 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
        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_MD5_HMAC;
+       if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+                       &cap_idx) == NULL)
+               return -ENOTSUP;
+
        if (MD5_HMAC_create_session(ts_params, ut_params,
                        RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
                return TEST_FAILED;
@@ -8376,8 +8926,14 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
        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");
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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");
@@ -8406,6 +8962,14 @@ test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
        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_MD5_HMAC;
+       if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
+                       &cap_idx) == NULL)
+               return -ENOTSUP;
+
        if (MD5_HMAC_create_session(ts_params, ut_params,
                        RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
                return TEST_FAILED;
@@ -8420,8 +8984,14 @@ test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
        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");
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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");
@@ -8464,6 +9034,19 @@ test_multi_session(void)
 
        uint16_t 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_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;
+
        test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
                        aes_cbc_key, hmac_sha512_key);
 
@@ -8579,6 +9162,19 @@ test_multi_session_random_usage(void)
 
        };
 
+       /* 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;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        sessions = rte_malloc(NULL,
@@ -8661,6 +9257,14 @@ test_null_cipher_only_operation(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_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;
+
        /* 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);
@@ -8727,6 +9331,14 @@ test_null_auth_only_operation(void)
        struct crypto_unittest_params *ut_params = &unittest_params;
        uint8_t *digest;
 
+       /* 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;
+
        /* 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);
@@ -8799,6 +9411,19 @@ test_null_cipher_auth_operation(void)
        struct crypto_unittest_params *ut_params = &unittest_params;
        uint8_t *digest;
 
+       /* 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;
+
        /* 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);
@@ -8887,6 +9512,19 @@ test_null_auth_cipher_operation(void)
        struct crypto_unittest_params *ut_params = &unittest_params;
        uint8_t *digest;
 
+       /* 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;
+
        /* Generate test mbuf data */
        ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
                        catch_22_quote, QUOTE_512_BYTES, 0);
@@ -8976,6 +9614,11 @@ test_null_invalid_operation(void)
        struct crypto_unittest_params *ut_params = &unittest_params;
        int ret;
 
+       /* 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;
@@ -9028,6 +9671,11 @@ test_null_burst_operation(void)
        struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
        struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
 
+       /* 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 = &ut_params->auth_xform;
@@ -9204,6 +9852,14 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
        TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
                              "No GMAC length in the source data");
 
+       /* 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;
+
        retval = create_gmac_session(ts_params->valid_devs[0],
                        tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
 
@@ -9247,7 +9903,12 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
 
        ut_params->op->sym->m_src = ut_params->ibuf;
 
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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,
@@ -9307,6 +9968,14 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
        TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
                              "No GMAC length in the source data");
 
+       /* 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;
+
        retval = create_gmac_session(ts_params->valid_devs[0],
                        tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
 
@@ -9351,7 +10020,12 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
 
        ut_params->op->sym->m_src = ut_params->ibuf;
 
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               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,
@@ -9865,6 +10539,14 @@ test_authentication_verify_fail_when_data_corruption(
 
        uint8_t *plaintext;
 
+       /* 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_session(ut_params,
                        ts_params->valid_devs[0],
@@ -9900,10 +10582,17 @@ test_authentication_verify_fail_when_data_corruption(
        else
                tag_corruption(plaintext, reference->plaintext.len);
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
                        ut_params->op);
-
-       TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
+               TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+                       RTE_CRYPTO_OP_STATUS_SUCCESS,
+                       "authentication not failed");
+       } else {
+               ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+                       ut_params->op);
+               TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
+       }
 
        return 0;
 }
@@ -9918,6 +10607,14 @@ test_authentication_verify_GMAC_fail_when_corruption(
        int retval;
        uint8_t *plaintext;
 
+       /* 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],
@@ -9956,10 +10653,17 @@ test_authentication_verify_GMAC_fail_when_corruption(
        else
                tag_corruption(plaintext, reference->aad.len);
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
                        ut_params->op);
-
-       TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
+               TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+                       RTE_CRYPTO_OP_STATUS_SUCCESS,
+                       "authentication not failed");
+       } else {
+               ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+                       ut_params->op);
+               TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
+       }
 
        return 0;
 }
@@ -9975,6 +10679,19 @@ test_authenticated_decryption_fail_when_corruption(
 
        uint8_t *ciphertext;
 
+       /* 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 */
        retval = create_auth_cipher_session(ut_params,
                        ts_params->valid_devs[0],
@@ -10011,10 +10728,17 @@ test_authenticated_decryption_fail_when_corruption(
        else
                tag_corruption(ciphertext, reference->ciphertext.len);
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
                        ut_params->op);
-
-       TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
+               TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
+                       RTE_CRYPTO_OP_STATUS_SUCCESS,
+                       "authentication not failed");
+       } else {
+               ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+                       ut_params->op);
+               TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
+       }
 
        return 0;
 }
@@ -10032,6 +10756,19 @@ test_authenticated_encryt_with_esn(
        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);
@@ -10089,8 +10826,12 @@ test_authenticated_encryt_with_esn(
        if (retval < 0)
                return retval;
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
                        ut_params->op);
+       else
+               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");
 
@@ -10135,6 +10876,19 @@ test_authenticated_decrypt_with_esn(
        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);
@@ -10192,7 +10946,11 @@ test_authenticated_decrypt_with_esn(
        if (retval < 0)
                return retval;
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_crypt_auth_op(ts_params->valid_devs[0],
+                       ut_params->op);
+       else
+               ut_params->op = process_crypto_request(ts_params->valid_devs[0],
                        ut_params->op);
 
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
@@ -10310,6 +11068,45 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
        int segs = 1;
        unsigned int trn_data = 0;
        uint8_t *plaintext, *ciphertext, *auth_tag;
+       struct rte_cryptodev_info dev_info;
+
+       /* 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;
+
+       /* OOP not supported with CPU crypto */
+       if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
+       /* 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;
+               }
+       }
 
        if (fragsz > tdata->plaintext.len)
                fragsz = tdata->plaintext.len;
@@ -10488,7 +11285,12 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
                ut_params->op->sym->m_dst = ut_params->obuf;
 
        /* Process crypto operation */
-       TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+       if (oop == IN_PLACE &&
+                       gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
+       else
+               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,
@@ -10567,6 +11369,10 @@ test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
 static int
 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
 {
+       /* This test is not for OPENSSL PMD */
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
+               return -ENOTSUP;
 
        return test_authenticated_encryption_SGL(
                        &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
@@ -10922,8 +11728,8 @@ static struct unit_test_suite cryptodev_scheduler_testsuite  = {
 
 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 
-static struct unit_test_suite cryptodev_qat_testsuite  = {
-       .suite_name = "Crypto QAT 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 = {
@@ -10933,8 +11739,15 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                                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_multi_session_random_usage),
+
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_null_invalid_operation),
+               TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
 
                TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
                TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
@@ -10962,11 +11775,43 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_CCM_authenticated_decryption_test_case_128_3),
 
-               /** AES GCM Authenticated Encryption */
+               /** AES CCM Authenticated Encryption 192 bits key */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
+                       test_AES_CCM_authenticated_encryption_test_case_192_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
+                       test_AES_CCM_authenticated_encryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_192_3),
+
+               /** AES CCM Authenticated Decryption 192 bits key*/
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_192_3),
+
+               /** AES CCM Authenticated Encryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_256_3),
+
+               /** AES CCM Authenticated Decryption 256 bits key*/
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_256_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,
@@ -10987,6 +11832,8 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                        test_AES_GCM_authenticated_encryption_test_case_7),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_authenticated_encryption_test_case_8),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_J0_authenticated_encryption_test_case_1),
 
                /** AES GCM Authenticated Decryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11005,6 +11852,8 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                        test_AES_GCM_authenticated_decryption_test_case_7),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_authenticated_decryption_test_case_8),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_J0_authenticated_decryption_test_case_1),
 
                /** AES GCM Authenticated Encryption 192 bits key */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11070,6 +11919,30 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                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),
+
+               /** Out of place tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_oop_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_oop_test_case_1),
+
+               /** 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),
@@ -11083,6 +11956,10 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                        test_AES_GMAC_authentication_test_case_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GMAC_authentication_verify_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GMAC_authentication_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GMAC_authentication_verify_test_case_4),
 
                /** SNOW 3G encrypt only (UEA2) */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11098,6 +11975,10 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
 
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_snow3g_encryption_test_case_1_oop),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_encryption_test_case_1_oop_sgl),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_encryption_test_case_1_offset_oop),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_snow3g_decryption_test_case_1_oop),
 
@@ -11160,12 +12041,26 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                        test_snow3g_hash_generate_test_case_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_snow3g_hash_generate_test_case_3),
+               /* Tests with buffers which length is not byte-aligned */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_hash_generate_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_hash_generate_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_hash_generate_test_case_6),
                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),
+               /* Tests with buffers which length is not byte-aligned */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_hash_verify_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_hash_verify_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_snow3g_hash_verify_test_case_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_snow3g_cipher_auth_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11182,8 +12077,20 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                        test_zuc_encryption_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_zuc_encryption_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_zuc_encryption_test_case_6_sgl),
 
                /** ZUC authenticate (EIA3) */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_zuc_hash_generate_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_zuc_hash_generate_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_zuc_hash_generate_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_zuc_hash_generate_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_zuc_hash_generate_test_case_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_zuc_hash_generate_test_case_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11227,11 +12134,7 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                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 */
+               /** KASUMI hash only (UIA1) */
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_hash_generate_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11252,706 +12155,19 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                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_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_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_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",
-       .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_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
-               TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_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_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),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GMAC_authentication_test_case_4),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GMAC_authentication_verify_test_case_4),
-
-               /** 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 CCM Authenticated Encryption 192 bits key */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_encryption_test_case_192_1),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_encryption_test_case_192_2),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_encryption_test_case_192_3),
-
-               /** AES CCM Authenticated Decryption 192 bits key*/
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_decryption_test_case_192_1),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_decryption_test_case_192_2),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_decryption_test_case_192_3),
-
-               /** AES CCM Authenticated Encryption 256 bits key */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_encryption_test_case_256_1),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_encryption_test_case_256_2),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_encryption_test_case_256_3),
-
-               /** AES CCM Authenticated Decryption 256 bits key*/
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_decryption_test_case_256_1),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_decryption_test_case_256_2),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_CCM_authenticated_decryption_test_case_256_3),
-
-               /** Scatter-Gather */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
-
-               /** 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,
-                       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),
-
-               /* ESN Testcase */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
-
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
-
-               TEST_CASES_END() /**< NULL terminate unit test array */
-       }
-};
-
-static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
-       .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
-       .setup = testsuite_setup,
-       .teardown = testsuite_teardown,
-       .unit_test_cases = {
-               /** 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_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),
-
-               /** 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_3),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GMAC_authentication_verify_test_case_3),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GMAC_authentication_test_case_4),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GMAC_authentication_verify_test_case_4),
-
-               /** Negative tests */
-               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),
-
-               /** Out of place tests */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_authenticated_encryption_oop_test_case_1),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_authenticated_decryption_oop_test_case_1),
-
-               /** 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),
-
-               /** Scatter-Gather */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
+                       test_kasumi_hash_verify_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
-
-               TEST_CASES_END() /**< NULL terminate unit test array */
-       }
-};
+                       test_kasumi_hash_verify_test_case_5),
 
-static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
-       .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
-       .setup = testsuite_setup,
-       .teardown = testsuite_teardown,
-       .unit_test_cases = {
                /** KASUMI encrypt only (UEA1) */
                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_1_sgl),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_encryption_test_case_1_oop),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_encryption_test_case_1_oop_sgl),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_encryption_test_case_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -11960,6 +12176,7 @@ static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
                        test_kasumi_encryption_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_encryption_test_case_5),
+
                /** KASUMI decrypt only (UEA1) */
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_decryption_test_case_1),
@@ -11971,39 +12188,9 @@ static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
                        test_kasumi_decryption_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_decryption_test_case_5),
-
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_kasumi_encryption_test_case_1_oop),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_kasumi_encryption_test_case_1_oop_sgl),
-
-
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_decryption_test_case_1_oop),
 
-               /** KASUMI hash only (UIA1) */
-               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_cipher_auth_test_case_1),
 
@@ -12030,152 +12217,143 @@ static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
                        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),
-               TEST_CASES_END() /**< NULL terminate unit test array */
-       }
-};
-static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
-       .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
-       .setup = testsuite_setup,
-       .teardown = testsuite_teardown,
-       .unit_test_cases = {
-               /** SNOW 3G encrypt only (UEA2) */
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_1),
+
+               /** ESN Testcase */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_2),
+                       auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_3),
+                       auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
+
+               /** Negative tests */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_4),
+                       authentication_verify_HMAC_SHA1_fail_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_5),
+                       authentication_verify_HMAC_SHA1_fail_tag_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_with_digest_test_case_1),
-
+                       test_AES_GCM_auth_encryption_fail_iv_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_1_oop),
+                       test_AES_GCM_auth_encryption_fail_in_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                               test_snow3g_encryption_test_case_1_oop_sgl),
+                       test_AES_GCM_auth_encryption_fail_out_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_test_case_1_oop),
-
+                       test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_encryption_test_case_1_offset_oop),
-
-               /** SNOW 3G decrypt only (UEA2) */
+                       test_AES_GCM_auth_encryption_fail_aad_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_test_case_1),
+                       test_AES_GCM_auth_encryption_fail_tag_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_test_case_2),
+                       test_AES_GCM_auth_decryption_fail_iv_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_test_case_3),
+                       test_AES_GCM_auth_decryption_fail_in_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_test_case_4),
+                       test_AES_GCM_auth_decryption_fail_out_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_test_case_5),
+                       test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_decryption_with_digest_test_case_1),
+                       test_AES_GCM_auth_decryption_fail_aad_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_generate_test_case_1),
+                       test_AES_GCM_auth_decryption_fail_tag_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_generate_test_case_2),
+                       authentication_verify_AES128_GMAC_fail_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_generate_test_case_3),
-               /* Tests with buffers which length is not byte-aligned */
+                       authentication_verify_AES128_GMAC_fail_tag_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_generate_test_case_4),
+                       auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_generate_test_case_5),
+                       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_snow3g_hash_generate_test_case_6),
+                       test_aes_cmac_aes_ctr_digest_enc_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_verify_test_case_1),
+                       test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_verify_test_case_2),
+                       test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_verify_test_case_3),
-               /* Tests with buffers which length is not byte-aligned */
+                       test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_verify_test_case_4),
+                       test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_verify_test_case_5),
+                      test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_hash_verify_test_case_6),
+                      test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_cipher_auth_test_case_1),
+                  test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
 
-               /** SNOW 3G generate auth, then encrypt (UEA2) */
+               /** AUTH ZUC + CIPHER SNOW3G */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_test_case_1),
+                       test_auth_zuc_cipher_snow_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_test_case_2),
+                       test_verify_auth_zuc_cipher_snow_test_case_1),
+               /** AUTH AES CMAC + CIPHER SNOW3G */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_test_case_2_oop),
+                       test_auth_aes_cmac_cipher_snow_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_part_digest_enc),
+                       test_verify_auth_aes_cmac_cipher_snow_test_case_1),
+               /** AUTH ZUC + CIPHER AES CTR */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_part_digest_enc_oop),
+                       test_auth_zuc_cipher_aes_ctr_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_test_case_3_sgl),
+                       test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
+               /** AUTH SNOW3G + CIPHER AES CTR */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_test_case_3_oop_sgl),
+                       test_auth_snow_cipher_aes_ctr_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_part_digest_enc_sgl),
+                       test_verify_auth_snow_cipher_aes_ctr_test_case_1),
+               /** AUTH SNOW3G + CIPHER ZUC */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
+                       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),
 
-               /** SNOW 3G decrypt (UEA2), then verify auth */
+               /** AUTH NULL + CIPHER SNOW3G */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_test_case_1),
+                       test_auth_null_cipher_snow_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_test_case_2),
+                       test_verify_auth_null_cipher_snow_test_case_1),
+               /** AUTH NULL + CIPHER ZUC */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_test_case_2_oop),
+                       test_auth_null_cipher_zuc_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_part_digest_enc),
+                       test_verify_auth_null_cipher_zuc_test_case_1),
+               /** AUTH SNOW3G + CIPHER NULL */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_part_digest_enc_oop),
+                       test_auth_snow_cipher_null_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_test_case_3_sgl),
+                       test_verify_auth_snow_cipher_null_test_case_1),
+               /** AUTH ZUC + CIPHER NULL */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
+                       test_auth_zuc_cipher_null_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
+                       test_verify_auth_zuc_cipher_null_test_case_1),
+               /** AUTH NULL + CIPHER AES CTR */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
+                       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_sw_zuc_testsuite  = {
-       .suite_name = "Crypto Device SW ZUC Unit Test Suite",
+static struct unit_test_suite cryptodev_virtio_testsuite = {
+       .suite_name = "Crypto VIRTIO Unit Test Suite",
        .setup = testsuite_setup,
        .teardown = testsuite_teardown,
        .unit_test_cases = {
-               /** 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),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_zuc_hash_generate_test_case_1),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_zuc_hash_generate_test_case_2),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_zuc_hash_generate_test_case_3),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_zuc_hash_generate_test_case_4),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_zuc_hash_generate_test_case_5),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_zuc_encryption_test_case_6_sgl),
+               TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
+
                TEST_CASES_END() /**< NULL terminate unit test array */
        }
 };
@@ -12730,23 +12908,6 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
        }
 };
 
-static struct unit_test_suite cryptodev_null_testsuite  = {
-       .suite_name = "Crypto Device NULL Unit Test Suite",
-       .setup = testsuite_setup,
-       .teardown = testsuite_teardown,
-       .unit_test_cases = {
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_null_invalid_operation),
-               TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_null_burst_operation),
-               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_CASES_END() /**< NULL terminate unit test array */
-       }
-};
-
 static struct unit_test_suite cryptodev_armv8_testsuite  = {
        .suite_name = "Crypto Device ARMv8 Unit Test Suite",
        .setup = testsuite_setup,
@@ -13037,6 +13198,7 @@ static struct unit_test_suite cryptodev_nitrox_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                                test_device_configure_invalid_queue_pair_ids),
                TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+               TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
 
                TEST_CASES_END() /**< NULL terminate unit test array */
        }
@@ -13262,7 +13424,7 @@ test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_qat_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
 }
 
 static int
@@ -13294,7 +13456,30 @@ test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
+}
+
+static int
+test_cryptodev_cpu_aesni_mb(void)
+{
+       int32_t rc;
+       enum rte_security_session_action_type at;
+
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_SKIPPED;
+       }
+
+       at = gbl_action_type;
+       gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
+       rc = unit_test_suite_runner(&cryptodev_testsuite);
+       gbl_action_type = at;
+       return rc;
 }
 
 static int
@@ -13310,7 +13495,7 @@ test_cryptodev_openssl(void)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_openssl_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
 }
 
 static int
@@ -13326,7 +13511,30 @@ test_cryptodev_aesni_gcm(void)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
+}
+
+static int
+test_cryptodev_cpu_aesni_gcm(void)
+{
+       int32_t rc;
+       enum rte_security_session_action_type at;
+
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_SKIPPED;
+       }
+
+       at = gbl_action_type;
+       gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
+       rc = unit_test_suite_runner(&cryptodev_testsuite);
+       gbl_action_type = at;
+       return rc;
 }
 
 static int
@@ -13342,7 +13550,7 @@ test_cryptodev_null(void)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_null_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
 }
 
 static int
@@ -13358,7 +13566,7 @@ test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
 }
 
 static int
@@ -13374,7 +13582,7 @@ test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
 }
 
 static int
@@ -13390,7 +13598,7 @@ test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
                return TEST_SKIPPED;
        }
 
-       return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
+       return unit_test_suite_runner(&cryptodev_testsuite);
 }
 
 static int
@@ -13565,8 +13773,12 @@ test_cryptodev_nitrox(void)
 
 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
+REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
+       test_cryptodev_cpu_aesni_mb);
 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
+REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
+       test_cryptodev_cpu_aesni_gcm);
 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);