diff --git a/autotest.sh b/autotest.sh
index b9a92d95e..27700e501 100755
--- a/autotest.sh
+++ b/autotest.sh
@@ -206,7 +206,7 @@ if [ $SPDK_RUN_FUNCTIONAL_TEST -eq 1 ]; then
 		timing_enter lvol
 		test_cases="1,50,51,52,53,100,101,102,150,200,201,250,251,252,253,254,255,"
 		test_cases+="300,301,450,451,452,500,550,551,552,553,"
-		test_cases+="600,601,602,650,651,652,654,655,"
+		test_cases+="600,601,602,650,651,652,653,654,655,"
 		test_cases+="700,701,702,750,751,752,753,754,755,756,757,758,759,760,"
 		test_cases+="800,801,802,803,804,10000"
 		run_test suite ./test/lvol/lvol.sh --test-cases=$test_cases
diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py
index d45f0adcd..2abbdde72 100644
--- a/test/lvol/test_cases.py
+++ b/test/lvol/test_cases.py
@@ -1650,27 +1650,68 @@ class TestCases(object):
         """
         thin_provisioning_resize
 
-        Check thin provisioned bdev resize. To be implemented.
+        Check thin provisioned bdev resize.
         """
-        # TODO
-        # create malloc bdev
-        # construct lvol store on malloc bdev
-        # construct thin provisioned lvol bdevs on created lvol store
+        # Create malloc bdev
+        base_name = self.c.construct_malloc_bdev(self.total_size,
+                                                 self.block_size)
+        # Construct lvol store on malloc bdev
+        uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name)
+        fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
+                                                  self.cluster_size)
+        # Construct thin provisioned lvol bdevs on created lvol store
         # with size equal to 50% of lvol store
-        # fill all free space of lvol bdev with data
-        # save number of free clusters for lvs
-        # resize bdev to full size of lvs
-        # check if bdev size changed (total_data_clusters*cluster_size
-        # equal to num_blocks*block_size)
-        # check if free_clusters on lvs remain unaffected
-        # perform write operation with verification
+        size = self.get_lvs_divided_size(2)
+        uuid_bdev = self.c.construct_lvol_bdev(uuid_store,
+                                               self.lbd_name, size, thin=True)
+        fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size)
+        # Fill all free space of lvol bdev with data
+        nbd_name = "/dev/nbd0"
+        fail_count += self.c.start_nbd_disk(uuid_bdev, nbd_name)
+        fail_count += self.run_fio_test(nbd_name, 0, size*MEGABYTE, "write", "0xcc", 0)
+        fail_count += self.c.stop_nbd_disk(nbd_name)
+        # Save number of free clusters for lvs
+        lvs = self.c.get_lvol_stores()[0]
+        free_clusters_start = int(lvs['free_clusters'])
+        # Resize bdev to full size of lvs
+        full_size = int(lvs['total_data_clusters'] * lvs['cluster_size'] / MEGABYTE)
+        fail_count += self.c.resize_lvol_bdev(uuid_bdev, full_size)
+        # Check if bdev size changed (total_data_clusters*cluster_size
+        # equals to num_blocks*block_size)
+        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
+        lbd_size = int(lvol_bdev['num_blocks'] * lvol_bdev['block_size'] / MEGABYTE)
+        if full_size != lbd_size:
+            fail_count += 1
+        # Check if free_clusters on lvs remain unaffected
+        lvs = self.c.get_lvol_stores()[0]
+        free_clusters_resize = int(lvs['free_clusters'])
+        if free_clusters_start != free_clusters_resize:
+            fail_count += 1
+        # Perform write operation with verification
         # to newly created free space of lvol bdev
-        # resize bdev to 30M and check if it ended with success
-        # check if free clusters on lvs equals to saved counter
-        # destroy thin provisioned lvol bdev
-        # destroy lvol store
-        # destroy malloc bdev
-        fail_count = 0
+        nbd_name = "/dev/nbd0"
+        fail_count += self.c.start_nbd_disk(uuid_bdev, nbd_name)
+        fail_count += self.run_fio_test(nbd_name, int(lbd_size * MEGABYTE / 2),
+                                        int(lbd_size * MEGABYTE / 2), "write", "0xcc", 0)
+        fail_count += self.c.stop_nbd_disk(nbd_name)
+        # Check if free clusters on lvs equals to zero
+        lvs = self.c.get_lvol_stores()[0]
+        if int(lvs['free_clusters']) != 0:
+            fail_count += 1
+        # Resize bdev to 25% of lvs and check if it ended with success
+        size = self.get_lvs_divided_size(4)
+        fail_count += self.c.resize_lvol_bdev(uuid_bdev, size)
+        # Check free clusters on lvs
+        lvs = self.c.get_lvol_stores()[0]
+        free_clusters_resize2 = int(lvs['free_clusters'])
+        free_clusters_expected = int((full_size - size) * MEGABYTE / lvs['cluster_size'])
+        if free_clusters_expected != free_clusters_resize2:
+            fail_count += 1
+
+        self.c.destroy_lvol_bdev(uuid_bdev)
+        self.c.destroy_lvol_store(uuid_store)
+        self.c.delete_malloc_bdev(base_name)
+
         # Expected result:
         # - calls successful, return code = 0
         # - no other operation fails