def METHOD_NAME(
    self,
    kms_provider,
    project_factory,
    storageclass_factory,
    multi_pvc_factory,
    pod_factory,
    kv_version,
):
    """
    Test to verify creation and deletion of encrypted RBD PVC
    """
    # Create a project
    proj_obj = project_factory()
    # Create an encryption enabled storageclass for RBD
    sc_obj = storageclass_factory(
        interface=constants.CEPHBLOCKPOOL,
        encrypted=True,
        encryption_kms_id=self.kms.kmsid,
    )
    if kms_provider == constants.VAULT_KMS_PROVIDER:
        # Create ceph-csi-kms-token in the tenant namespace
        self.kms.vault_path_token = self.kms.generate_vault_token()
        self.kms.create_vault_csi_kms_token(namespace=proj_obj.namespace)
    # Create RBD PVCs with volume mode Block
    pvc_size = 5
    pvc_objs = multi_pvc_factory(
        interface=constants.CEPHBLOCKPOOL,
        project=proj_obj,
        storageclass=sc_obj,
        size=pvc_size,
        access_modes=[
            f"{constants.ACCESS_MODE_RWX}-Block",
            f"{constants.ACCESS_MODE_RWO}-Block",
        ],
        status=constants.STATUS_BOUND,
        num_of_pvc=3,
        wait_each=False,
    )
    # Create pods
    pod_objs = create_pods(
        pvc_objs,
        pod_factory,
        constants.CEPHBLOCKPOOL,
        pods_for_rwx=1,
        status=constants.STATUS_RUNNING,
    )
    # Verify if the key is created in Vault
    vol_handles = []
    for pvc_obj in pvc_objs:
        pv_obj = pvc_obj.backed_pv_obj
        vol_handle = pv_obj.get().get("spec").get("csi").get("volumeHandle")
        vol_handles.append(vol_handle)
        if kms_provider == constants.VAULT_KMS_PROVIDER:
            # Check if encryption key is created in Vault
            if kms.is_key_present_in_path(
                key=vol_handle, path=self.kms.vault_backend_path
            ):
                log.info(f"Vault: Found key for {pvc_obj.name}")
            else:
                raise ResourceNotFoundError(
                    f"Vault: Key not found for {pvc_obj.name}"
                )
    # Verify whether encrypted device is present inside the pod and run IO
    for vol_handle, pod_obj in zip(vol_handles, pod_objs):
        if pod_obj.exec_sh_cmd_on_pod(
            command=f"lsblk | grep {vol_handle} | grep crypt"
        ):
            log.info(f"Encrypted device found in {pod_obj.name}")
        else:
            log.error(f"Encrypted device not found in {pod_obj.name}")
        pod_obj.run_io(
            storage_type="block",
            size=f"{pvc_size - 1}G",
            io_direction="write",
            runtime=60,
        )
    log.info("IO started on all pods")
    # Wait for IO completion
    for pod_obj in pod_objs:
        pod_obj.get_fio_results()
    log.info("IO completed on all pods")
    # Delete the pod
    for pod_obj in pod_objs:
        pod_obj.delete()
        pod_obj.ocp.wait_for_delete(resource_name=pod_obj.name)
    # Delete the PVC
    for pvc_obj in pvc_objs:
        pv_obj = pvc_obj.backed_pv_obj
        pvc_obj.delete()
        pv_obj.ocp.wait_for_delete(resource_name=pv_obj.name)
    if kms_provider == constants.VAULT_KMS_PROVIDER:
        # Verify whether the key is deleted in Vault
        if kv_version == "v1" or Version.coerce(
            config.ENV_DATA["ocs_version"]
        ) >= Version.coerce("4.9"):
            for vol_handle in vol_handles:
                if not kms.is_key_present_in_path(
                    key=vol_handle, path=self.kms.vault_backend_path
                ):
                    log.info(f"Vault: Key deleted for {vol_handle}")
                else:
                    raise KMSResourceCleaneupError(
                        f"Vault: Key deletion failed for {vol_handle}"
                    )