test/crypto: skip unsupported non-byte aligned cases
[dpdk.git] / app / test / test_cryptodev.c
index ba6b7b2..df2c56c 100644 (file)
@@ -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;
@@ -1447,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");
@@ -1598,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");
@@ -1630,7 +1735,6 @@ test_blockcipher(enum blockcipher_test_type test_type)
                ts_params->op_mpool,
                ts_params->session_mpool, ts_params->session_priv_mpool,
                ts_params->valid_devs[0],
-               gbl_driver_id,
                test_type);
 
        if (status == -ENOTSUP)
@@ -2357,12 +2461,16 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
        unsigned plaintext_pad_len;
        unsigned plaintext_len;
        uint8_t *plaintext;
+       struct rte_cryptodev_info dev_info;
+
+       rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+       uint64_t feat_flags = dev_info.feature_flags;
 
-       /* 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))))
+       if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
+                       ((tdata->validAuthLenInBits.len % 8) != 0)) {
+               printf("Device doesn't support NON-Byte Aligned Data.\n");
                return -ENOTSUP;
+       }
 
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2431,12 +2539,16 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
        unsigned plaintext_pad_len;
        unsigned plaintext_len;
        uint8_t *plaintext;
+       struct rte_cryptodev_info dev_info;
+
+       rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+       uint64_t feat_flags = dev_info.feature_flags;
 
-       /* 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))))
+       if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
+                       ((tdata->validAuthLenInBits.len % 8) != 0)) {
+               printf("Device doesn't support NON-Byte Aligned Data.\n");
                return -ENOTSUP;
+       }
 
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2546,8 +2658,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 *)
@@ -3530,11 +3647,16 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        uint32_t plaintext_pad_len;
        uint8_t extra_offset = 4;
        uint8_t *expected_ciphertext_shifted;
+       struct rte_cryptodev_info dev_info;
 
-       /* QAT PMD supports byte-aligned data only */
-       if (gbl_driver_id == rte_cryptodev_driver_id_get(
-                       RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)))
+       rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+       uint64_t feat_flags = dev_info.feature_flags;
+
+       if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
+                       ((tdata->validDataLenInBits.len % 8) != 0)) {
+               printf("Device doesn't support NON-Byte Aligned Data.\n");
                return -ENOTSUP;
+       }
 
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3788,8 +3910,19 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata)
        unsigned int plaintext_pad_len;
        unsigned int plaintext_len;
 
+       struct rte_cryptodev_info dev_info;
        struct rte_cryptodev_sym_capability_idx cap_idx;
 
+       rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+       uint64_t feat_flags = dev_info.feature_flags;
+
+       if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
+                       ((tdata->validAuthLenInBits.len % 8 != 0) ||
+                       (tdata->validDataLenInBits.len % 8 != 0))) {
+               printf("Device doesn't support NON-Byte Aligned Data.\n");
+               return -ENOTSUP;
+       }
+
        /* Check if device supports ZUC EEA3 */
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
        cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
@@ -4977,12 +5110,16 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
        uint8_t *plaintext;
 
        struct rte_cryptodev_sym_capability_idx cap_idx;
+       struct rte_cryptodev_info dev_info;
+
+       rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+       uint64_t feat_flags = dev_info.feature_flags;
 
-       /* 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))))
+       if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
+                       (tdata->validAuthLenInBits.len % 8 != 0)) {
+               printf("Device doesn't support NON-Byte Aligned Data.\n");
                return -ENOTSUP;
+       }
 
        /* Check if device supports ZUC EIA3 */
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -5071,11 +5208,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 */
@@ -5925,11 +6060,6 @@ 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);
 }
 
@@ -5954,11 +6084,6 @@ 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);
 }
@@ -6060,11 +6185,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 */
@@ -6798,9 +6921,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 */
@@ -6941,7 +7070,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,
@@ -7621,6 +7754,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)
 {
@@ -7872,7 +8011,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,
@@ -7950,6 +8093,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)
 {
@@ -8158,6 +8307,10 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata)
                        &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,
@@ -8243,6 +8396,10 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata)
                        &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,
@@ -8322,6 +8479,10 @@ test_authenticated_encryption_sessionless(
                                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;
@@ -8418,6 +8579,10 @@ test_authenticated_decryption_sessionless(
                                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;
@@ -8604,6 +8769,9 @@ 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;
@@ -8775,8 +8943,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");
@@ -8827,8 +9001,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");
@@ -9740,7 +9920,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,
@@ -9852,7 +10037,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,
@@ -10409,10 +10599,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;
 }
@@ -10473,10 +10670,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;
 }
@@ -10541,10 +10745,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;
 }
@@ -10632,8 +10843,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");
 
@@ -10748,7 +10963,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");
@@ -10876,6 +11095,10 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
                        &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) {
@@ -11079,7 +11302,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,
@@ -11517,8 +11745,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 = {
@@ -11528,8 +11756,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),
@@ -11557,6 +11792,38 @@ 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 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),
+
                /** AES GCM Authenticated Encryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
@@ -11582,6 +11849,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,
@@ -11600,6 +11869,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,
@@ -11665,6 +11936,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),
@@ -11678,6 +11973,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,
@@ -11693,6 +11992,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),
 
@@ -11755,12 +12058,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,
@@ -11777,8 +12094,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,
@@ -11822,11 +12151,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,
@@ -11851,702 +12176,15 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_hash_verify_test_case_5),
 
+               /** 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_3),
+                       test_kasumi_encryption_test_case_1_sgl),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_kasumi_cipher_auth_test_case_1),
-
-               /** KASUMI generate auth, then encrypt (F8) */
+                       test_kasumi_encryption_test_case_1_oop),
                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_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 */
-       }
-};
-
-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_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,
@@ -12555,6 +12193,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),
@@ -12566,39 +12205,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),
 
@@ -12625,152 +12234,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 */
        }
 };
@@ -13325,23 +12925,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,
@@ -13632,6 +13215,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 */
        }
@@ -13857,7 +13441,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
@@ -13889,7 +13473,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
@@ -13905,7 +13512,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
@@ -13921,7 +13528,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
@@ -13937,7 +13567,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
@@ -13953,7 +13583,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
@@ -13969,7 +13599,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
@@ -13985,7 +13615,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
@@ -14160,8 +13790,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);