diff --git a/test/lvol/lvol.sh b/test/lvol/lvol.sh
index da726cd20..032cbc526 100755
--- a/test/lvol/lvol.sh
+++ b/test/lvol/lvol.sh
@@ -21,7 +21,6 @@ function usage() {
     echo "    --block-size          Block size for this bdev"
     echo "-x                        set -x for script debug"
     echo "    --test-cases=         List test cases which will be run:
-                                    254: 'destroy_after_bdev_lvol_resize_positive',
                                     255: 'delete_lvol_store_persistent_positive',
                                     350: 'nested_destroy_logical_volume_negative',
                                     400: 'nested_construct_logical_volume_positive',
diff --git a/test/lvol/resize.sh b/test/lvol/resize.sh
index e28ac002b..ba9c9dc53 100755
--- a/test/lvol/resize.sh
+++ b/test/lvol/resize.sh
@@ -154,6 +154,56 @@ function test_resize_lvol_with_io_traffic() {
 	rpc_cmd bdev_malloc_delete "$malloc_name"
 }
 
+# Positive test for destroying a logical_volume after resizing.
+# Call bdev_lvol_delete_lvstore with correct logical_volumes name.
+function test_destroy_after_bdev_lvol_resize_positive() {
+	local malloc_dev
+	local lvstore_name=lvs_test lvstore_uuid
+	local lbd_name=lbd_test bdev_uuid bdev_size
+
+	malloc_dev=$(rpc_cmd bdev_malloc_create 256 "$MALLOC_BS")
+	lvstore_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_dev" "$lvstore_name")
+
+	get_lvs_jq bdev_lvol_get_lvstores -u "$lvstore_uuid"
+	[[ ${jq_out["uuid"]} == "$lvstore_uuid" ]]
+	[[ ${jq_out["name"]} == "$lvstore_name" ]]
+
+	bdev_size=$(round_down $(( LVS_DEFAULT_CAPACITY_MB / 4 )))
+	bdev_uuid=$(rpc_cmd bdev_lvol_create -u "$lvstore_uuid" "$lbd_name" "$bdev_size")
+
+	# start resizing in the following fashion:
+	# - size is equal to one quarter of size malloc bdev plus 4 MB
+	# - size is equal half of size malloc bdev
+	# - size is equal to three quarters of size malloc bdev
+	# - size is equal to size if malloc bdev minus 4 MB
+	# - size is equal 0 MiB
+	local resize
+	for resize in \
+	  "$bdev_size" \
+	  $(( bdev_size + 4 )) \
+	  $(( bdev_size * 2 )) \
+	  $(( bdev_size * 3 )) \
+	  $(( bdev_size * 4 - 4 )) \
+	  0; do
+		resize=$(round_down $(( resize / 4 )))
+		rpc_cmd bdev_lvol_resize "$bdev_uuid" "$resize"
+
+		get_bdev_jq bdev_get_bdevs -b "$bdev_uuid"
+		[[ ${jq_out["name"]} == "$bdev_uuid" ]]
+		[[ ${jq_out["name"]} == "${jq_out["uuid"]}" ]]
+		(( jq_out["block_size"] == MALLOC_BS ))
+		(( jq_out["num_blocks"] * jq_out["block_size"] == resize * 1024**2 ))
+	done
+
+	# cleanup
+	rpc_cmd bdev_lvol_delete "$bdev_uuid"
+	rpc_cmd bdev_lvol_delete_lvstore -u "$lvstore_uuid"
+	rpc_cmd bdev_get_bdevs -b "$bdev_uuid" && false
+	rpc_cmd bdev_lvol_get_lvstores -u "$lvstore_uuid" && false
+	rpc_cmd bdev_malloc_delete "$malloc_dev"
+	check_leftover_devices
+}
+
 modprobe nbd
 $rootdir/app/spdk_tgt/spdk_tgt &
 spdk_pid=$!
@@ -163,6 +213,7 @@ waitforlisten $spdk_pid
 run_test "test_resize_lvol" test_resize_lvol
 run_test "test_resize_lvol_negative" test_resize_lvol_negative
 run_test "test_resize_lvol_with_io_traffic" test_resize_lvol_with_io_traffic
+run_test "test_destroy_after_bdev_lvol_resize_positive" test_destroy_after_bdev_lvol_resize_positive
 
 trap - SIGINT SIGTERM EXIT
 killprocess $spdk_pid
diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py
index a79dc9975..1695d9d50 100644
--- a/test/lvol/test_cases.py
+++ b/test/lvol/test_cases.py
@@ -112,7 +112,6 @@ def case_message(func):
     def inner(*args, **kwargs):
         test_name = {
             # bdev_lvol_delete_lvstore - positive tests
-            254: 'destroy_after_bdev_lvol_resize_positive',
             255: 'delete_lvol_store_persistent_positive',
             551: 'delete_lvol_bdev',
             552: 'bdev_lvol_delete_lvstore_with_clones',
@@ -252,74 +251,6 @@ class TestCases(object):
         lvs = self.c.bdev_lvol_get_lvstores(lvs_name)[0]
         return int(int(lvs['cluster_size']) / MEGABYTE)
 
-    @case_message
-    def test_case254(self):
-        """
-        destroy_resize_logical_volume_positive
-
-        Positive test for destroying a logical_volume after resizing.
-        Call bdev_lvol_delete_lvstore with correct logical_volumes name.
-        """
-        # Create malloc bdev
-        base_name = self.c.bdev_malloc_create(self.total_size,
-                                              self.block_size)
-        # Construct lvol store on create malloc bdev
-        uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
-                                                     self.lvs_name)
-        # Check correct uuid values in response bdev_lvol_get_lvstores command
-        fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
-                                                         self.cluster_size)
-        size = self.get_lvs_divided_size(4)
-        # bdev_lvol_create on correct lvs_uuid and size is
-        # equal to one quarter of size malloc bdev
-        uuid_bdev = self.c.bdev_lvol_create(uuid_store,
-                                            self.lbd_name,
-                                            size)
-        # check size of the lvol bdev
-        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, size)
-        sz = size + 4
-        # Resize_lvol_bdev on correct lvs_uuid and size is
-        # equal to one quarter of size malloc bdev plus 4 MB
-        self.c.bdev_lvol_resize(uuid_bdev, sz)
-        # check size of the lvol bdev by command RPC : bdev_get_bdevs
-        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)
-        # Resize_lvol_bdev on correct lvs_uuid and size is
-        # equal half of size malloc bdev
-        sz = size * 2
-        self.c.bdev_lvol_resize(uuid_bdev, sz)
-        # check size of the lvol bdev by command RPC : bdev_get_bdevs
-        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)
-        # Resize_lvol_bdev on correct lvs_uuid and size is
-        # equal to three quarters of size malloc bdev
-        sz = size * 3
-        self.c.bdev_lvol_resize(uuid_bdev, sz)
-        # check size of the lvol bdev by command RPC : bdev_get_bdevs
-        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)
-        # Resize_lvol_bdev on correct lvs_uuid and size is
-        # equal to size if malloc bdev minus 4 MB
-        sz = (size * 4) - 4
-        self.c.bdev_lvol_resize(uuid_bdev, sz)
-        # check size of the lvol bdev by command RPC : bdev_get_bdevs
-        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)
-        # Resize_lvol_bdev on the correct lvs_uuid and size is equal 0 MiB
-        sz = 0
-        self.c.bdev_lvol_resize(uuid_bdev, sz)
-        # check size of the lvol bdev by command RPC : bdev_get_bdevs
-        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, sz)
-
-        # Destroy lvol store
-        self.c.bdev_lvol_delete_lvstore(uuid_store)
-        if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
-            fail_count += 1
-        self.c.bdev_malloc_delete(base_name)
-
-        # Expected result:
-        # - lvol bdev should change size after resize operations
-        # - calls successful, return code = 0
-        # - no other operation fails
-        # - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
-        return fail_count
-
     @case_message
     def test_case255(self):
         """