diff --git a/autotest.sh b/autotest.sh index 6ab8c9cfd..f2fa34e1b 100755 --- a/autotest.sh +++ b/autotest.sh @@ -149,7 +149,7 @@ fi if [ $SPDK_TEST_LVOL -eq 1 ]; then timing_enter lvol - run_test ./test/lvol/lvol.sh --test-cases=1,2,3,5,6,7,10,11,12,13,16,17,21,22,23,24 + run_test ./test/lvol/lvol.sh --test-cases=1,2,3,4,5,7,8,9,10,13,14,15,16,17,18,21,22,25,26,27,28,29 timing_exit lvol fi diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py index 21620c317..66751b40e 100644 --- a/test/lvol/test_cases.py +++ b/test/lvol/test_cases.py @@ -26,27 +26,32 @@ def header(num): 1: 'construct_lvs_positive', 2: 'construct_logical_volume_positive', 3: 'construct_multi_logical_volumes_positive', - 4: 'resize_lvol_bdev_positive', - 5: 'destroy_lvol_store_positive', - 6: 'destroy_lvol_store_with_lvol_bdev_positive', - 7: 'destroy_multi_logical_volumes_positive', - 8: 'nested_construct_logical_volume_positive', - 9: 'destroy_after_resize_lvol_bdev_positive', - 10: 'construct_lvs_nonexistent_bdev', - 11: 'construct_lvs_on_bdev_twic_negative', - 12: 'construct_logical_volume_nonexistent_lvs_uuid', - 13: 'construct_lvol_bdev_on_full_lvol_store', - 14: 'resize_logical_volume_nonexistent_logical_volume', - 15: 'resize_logical_volume_with_size_out_of_range', - 16: 'destroy_lvol_store_nonexistent_lvs_uuid', - 17: 'destroy_lvol_store_nonexistent_bdev', - 18: 'nested_construct_lvol_bdev_on_full_lvol_store', - 19: 'nested_destroy_logical_volume_positive', - 20: 'delete_bdev_positive', - 21: 'construct_lvs_with_cluster_sz_out_of_range_max', - 22: 'construct_lvs_with_cluster_sz_out_of_range_min', - 23: 'tasting_positive', - 24: 'SIGTERM', + 4: 'construct_lvol_bdev_using_name_positive', + 5: 'construct_lvol_bdev_duplicate_names_positive', + 6: 'resize_lvol_bdev_positive', + 7: 'destroy_lvol_store_positive', + 8: 'destroy_lvol_store_use_name_positive', + 9: 'destroy_lvol_store_with_lvol_bdev_positive', + 10: 'destroy_multi_logical_volumes_positive', + 11: 'nested_construct_logical_volume_positive', + 12: 'destroy_after_resize_lvol_bdev_positive', + 13: 'construct_lvs_nonexistent_bdev', + 14: 'construct_lvs_on_bdev_twice', + 15: 'construct_lvs_name_twice', + 16: 'construct_logical_volume_nonexistent_lvs_uuid', + 17: 'construct_lvol_bdev_on_full_lvol_store', + 18: 'construct_lvol_bdev_name_twice', + 19: 'resize_logical_volume_nonexistent_logical_volume', + 20: 'resize_logical_volume_with_size_out_of_range', + 21: 'destroy_lvol_store_nonexistent_lvs_uuid', + 22: 'delete_lvol_store_underlying_bdev', + 23: 'nested_construct_lvol_bdev_on_full_lvol_store', + 24: 'nested_destroy_logical_volume_negative', + 25: 'delete_bdev_positive', + 26: 'construct_lvol_store_with_cluster_size_max', + 27: 'construct_lvol_store_with_cluster_size_min', + 28: 'tasting_positive', + 29: 'SIGTERM', } print("========================================================") print("Test Case {num}: Start".format(num=num)) @@ -199,6 +204,66 @@ class TestCases(object): def test_case4(self): header(4) + base_name = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + + uuid_store = self.c.construct_lvol_store(base_name, + self.lvs_name, + self.cluster_size) + + fail_count = self.c.check_get_lvol_stores(base_name, uuid_store, + self.cluster_size) + + uuid_bdev = self.c.construct_lvol_bdev(self.lvs_name, + self.lbd_name, + self.total_size - 1) + fail_count += self.c.check_get_bdevs_methods(uuid_bdev, + self.total_size - 1) + + fail_count += self.c.delete_bdev(uuid_bdev) + fail_count += self.c.destroy_lvol_store(uuid_store) + fail_count += self.c.delete_bdev(base_name) + footer(4) + return fail_count + + def test_case5(self): + header(5) + base_name_1 = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + base_name_2 = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + + uuid_store_1 = self.c.construct_lvol_store(base_name_1, + self.lvs_name + "1", + self.cluster_size) + uuid_store_2 = self.c.construct_lvol_store(base_name_2, + self.lvs_name + "2", + self.cluster_size) + fail_count = self.c.check_get_lvol_stores(base_name_1, uuid_store_1, + self.cluster_size) + fail_count = self.c.check_get_lvol_stores(base_name_2, uuid_store_2, + self.cluster_size) + + uuid_bdev_1 = self.c.construct_lvol_bdev(uuid_store_1, + self.lbd_name, + self.total_size - 1) + uuid_bdev_2 = self.c.construct_lvol_bdev(uuid_store_2, + self.lbd_name, + self.total_size - 1) + fail_count += self.c.check_get_bdevs_methods(uuid_bdev_1, self.total_size - 1) + fail_count += self.c.check_get_bdevs_methods(uuid_bdev_2, self.total_size - 1) + + fail_count += self.c.delete_bdev(uuid_bdev_1) + fail_count += self.c.delete_bdev(uuid_bdev_2) + fail_count += self.c.destroy_lvol_store(uuid_store_1) + fail_count += self.c.destroy_lvol_store(uuid_store_2) + fail_count += self.c.delete_bdev(base_name_1) + fail_count += self.c.delete_bdev(base_name_2) + footer(5) + return fail_count + + def test_case6(self): + header(6) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -227,11 +292,11 @@ class TestCases(object): self.c.delete_bdev(uuid_bdev) self.c.destroy_lvol_store(uuid_store) self.c.delete_bdev(base_name) - footer(4) + footer(6) return fail_count - def test_case5(self): - header(5) + def test_case7(self): + header(7) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -242,11 +307,26 @@ class TestCases(object): self.c.destroy_lvol_store(uuid_store) fail_count += self.c.check_get_lvol_stores("", "", "") self.c.delete_bdev(base_name) - footer(5) + footer(7) return fail_count - def test_case6(self): - header(6) + def test_case8(self): + header(8) + base_name = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + uuid_store = self.c.construct_lvol_store(base_name, + self.lvs_name, + self.cluster_size) + fail_count = self.c.check_get_lvol_stores(base_name, uuid_store, + self.cluster_size) + fail_count += self.c.destroy_lvol_store(self.lvs_name) + fail_count += self.c.check_get_lvol_stores("", "", "") + fail_count += self.c.delete_bdev(base_name) + footer(8) + return fail_count + + def test_case9(self): + header(9) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -264,11 +344,11 @@ class TestCases(object): fail_count += self.c.check_get_lvol_stores("", "", "") self.c.delete_bdev(base_name) - footer(6) + footer(9) return fail_count - def test_case7(self): - header(7) + def test_case10(self): + header(10) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -287,16 +367,16 @@ class TestCases(object): self.c.destroy_lvol_store(uuid_store) fail_count += self.c.check_get_lvol_stores("", "", "") self.c.delete_bdev(base_name) - footer(7) + footer(10) return fail_count - def test_case8(self): + def test_case11(self): print("Test of this feature not yet implemented.") pass return 0 - def test_case9(self): - header(9) + def test_case12(self): + header(12) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -322,23 +402,23 @@ class TestCases(object): self.c.destroy_lvol_store(uuid_store) fail_count += self.c.check_get_lvol_stores("", "", "") self.c.delete_bdev(base_name) - footer(9) + footer(12) return fail_count # negative tests - def test_case10(self): - header(10) + def test_case13(self): + header(13) fail_count = 0 bad_bdev_id = random.randrange(999999999) if self.c.construct_lvol_store(bad_bdev_id, self.lvs_name, self.cluster_size) == 0: fail_count += 1 - footer(10) + footer(13) return fail_count - def test_case11(self): - header(11) + def test_case14(self): + header(14) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -352,21 +432,46 @@ class TestCases(object): fail_count += 1 self.c.destroy_lvol_store(uuid_store) self.c.delete_bdev(base_name) - footer(11) + footer(14) return fail_count - def test_case12(self): - header(12) + def test_case15(self): + header(15) + fail_count = 0 + base_name_1 = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + base_name_2 = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + uuid_store_1 = self.c.construct_lvol_store(base_name_1, + self.lvs_name, + self.cluster_size) + fail_count += self.c.check_get_lvol_stores(base_name_1, + uuid_store_1, + self.cluster_size) + if self.c.construct_lvol_store(base_name_2, + self.lvs_name, + self.cluster_size) == 0: + fail_count += 1 + + fail_count += self.c.destroy_lvol_store(uuid_store_1) + fail_count += self.c.delete_bdev(base_name_1) + fail_count += self.c.delete_bdev(base_name_2) + + footer(15) + return fail_count + + def test_case16(self): + header(16) fail_count = 0 if self.c.construct_lvol_bdev(self._gen_lvs_uudi(), self.lbd_name, 32) == 0: fail_count += 1 - footer(12) + footer(16) return fail_count - def test_case13(self): - header(13) + def test_case17(self): + header(17) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -387,19 +492,45 @@ class TestCases(object): self.c.delete_bdev(uuid_bdev) self.c.destroy_lvol_store(uuid_store) self.c.delete_bdev(base_name) - footer(13) + footer(17) return fail_count - def test_case14(self): - header(14) + def test_case18(self): + header(18) + size = (self.total_size / 2) - 1 + base_name = self.c.construct_malloc_bdev(self.total_size, + self.block_size) + uuid_store = self.c.construct_lvol_store(base_name, + self.lvs_name, + self.cluster_size) + fail_count = self.c.check_get_lvol_stores(base_name, uuid_store, + self.cluster_size) + uuid_bdev = self.c.construct_lvol_bdev(uuid_store, + self.lbd_name, + size) + fail_count += self.c.check_get_bdevs_methods(uuid_bdev, + size) + if self.c.construct_lvol_bdev(uuid_store, + self.lbd_name, + size) == 0: + fail_count += 1 + + self.c.delete_bdev(uuid_bdev) + self.c.destroy_lvol_store(uuid_store) + self.c.delete_bdev(base_name) + footer(18) + return fail_count + + def test_case19(self): + header(19) fail_count = 0 if self.c.resize_lvol_bdev(self._gen_lvb_uudi(), 16) == 0: fail_count += 1 - footer(14) + footer(19) return fail_count - def test_case15(self): - header(15) + def test_case20(self): + header(20) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -418,19 +549,19 @@ class TestCases(object): self.c.delete_bdev(uuid_bdev) self.c.destroy_lvol_store(uuid_store) self.c.delete_bdev(base_name) - footer(15) + footer(20) return fail_count - def test_case16(self): - header(16) + def test_case21(self): + header(21) fail_count = 0 if self.c.destroy_lvol_store(self._gen_lvs_uudi()) == 0: fail_count += 1 - footer(16) + footer(21) return fail_count - def test_case17(self): - header(17) + def test_case22(self): + header(22) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -445,21 +576,21 @@ class TestCases(object): if self.c.destroy_lvol_store(uuid_store) == 0: fail_count += 1 - footer(17) + footer(22) return fail_count - def test_case18(self): + def test_case23(self): print("Test of this feature not yet implemented.") pass return 0 - def test_case19(self): + def test_case24(self): print("Test of this feature not yet implemented.") pass return 0 - def test_case20(self): - header(20) + def test_case25(self): + header(25) base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) uuid_store = self.c.construct_lvol_store(base_name, @@ -469,11 +600,11 @@ class TestCases(object): self.cluster_size) self.c.delete_bdev(base_name) fail_count += self.c.check_get_lvol_stores("", "", "") - footer(20) + footer(25) return fail_count - def test_case21(self): - header(21) + def test_case26(self): + header(26) fail_count = 0 base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) @@ -481,22 +612,22 @@ class TestCases(object): self.lvs_name, (self.total_size * 1024 * 1024) + 1) == 0: fail_count += 1 - footer(21) + footer(26) return fail_count - def test_case22(self): - header(22) + def test_case27(self): + header(27) fail_count = 0 base_name = self.c.construct_malloc_bdev(self.total_size, self.block_size) if self.c.construct_lvol_store(base_name, self.lvs_name, 0) == 0: fail_count += 1 - footer(22) + footer(27) return fail_count - def test_case23(self): - header(23) + def test_case28(self): + header(28) fail_count = 0 uuid_bdevs = [] base_name = "Nvme0n1" @@ -535,7 +666,7 @@ class TestCases(object): remove(pid_path) if self._start_vhost(vhost_path, config_path, pid_path) != 0: fail_count += 1 - footer(23) + footer(28) return fail_count # Check if configuration was properly loaded after tasting @@ -562,7 +693,7 @@ class TestCases(object): pprint.pprint([o, n]) if fail_count != 0: - footer(23) + footer(28) return fail_count # Try modifying loaded configuration @@ -600,11 +731,11 @@ class TestCases(object): if self.c.destroy_lvol_store(uuid_store) != 0: fail_count += 1 - footer(23) + footer(28) return fail_count - def test_case24(self): - header(24) + def test_case29(self): + header(29) pid_path = path.join(self.path, 'vhost.pid') base_name = self.c.construct_malloc_bdev(self.total_size, @@ -616,5 +747,5 @@ class TestCases(object): self.cluster_size) fail_count += self._stop_vhost(pid_path) - footer(24) + footer(29) return fail_count diff --git a/test/lvol/test_plan.md b/test/lvol/test_plan.md index 584508bdc..53dfb5dac 100644 --- a/test/lvol/test_plan.md +++ b/test/lvol/test_plan.md @@ -78,9 +78,49 @@ Expected result: field set with the same name as returned from RPC call for all repeat - no other operation fails +#### TEST CASE 4 - Name: construct_lvol_bdev_using_name_positive +Positive test for constructing a logical volume using friendly names. +Verify that logical volumes can be created by using a friendly name +instead of uuid when referencing to lvol store. +Steps: +- create malloc bdev +- create logical volume store on created malloc bdev +- verify lvol store was created correctly +- create logical volume on lvol store by using a friendly name + as a reference +- verify logical volume was correctly created +- delete logical volume bdev +- destroy logical volume store +- delete malloc bdev + +Expected result: +- calls successful, return code = 0 +- no other operation fails + +#### TEST CASE 5 - Name: construct_lvol_bdev_duplicate_names_positive +Positive test for constructing a logical volumes using friendly names. +Verify that logical volumes can use the same argument for friendly names +if they are created on separate logical volume stores. +Steps: +- create two malloc bdevs +- create logical volume stores on created malloc bdevs +- verify stores were created correctly +- create logical volume on first lvol store +- verify it was correctly created +- using the same friendly name argument create logical volume on second + lvol store +- verify logical volume was correctly created +- delete logical volume bdevs +- destroy logical volume stores +- delete malloc bdevs + +Expected result: +- calls successful, return code = 0 +- no other operation fails + ### resize_lvol_store - positive tests -#### TEST CASE 4 - Name: resize_logical_volume_positive +#### TEST CASE 6 - Name: resize_logical_volume_positive Positive test for resizing a logical_volume. Call resize_lvol_bdev with correct logical_volumes name and new size. Steps: @@ -109,7 +149,7 @@ Expected result: ### destroy_lvol_store - positive tests -#### TEST CASE 5 - Name: destroy_lvol_store_positive +#### TEST CASE 7 - Name: destroy_lvol_store_positive Positive test for destroying a logical volume store. Call destroy_lvol_store with correct logical_volumes name Steps: @@ -125,7 +165,24 @@ Expected result: - get_lvol_stores: response should be of no value after destroyed lvol store - no other operation fails -#### TEST CASE 6 - Name: destroy_lvol_store_with_lvol_bdev_positive +#### TEST CASE 8 - Name: destroy_lvol_store_use_name_positive +Positive test for destroying a logical volume store using +lvol store name instead of uuid for reference. +Call destroy_lvol_store with correct logical volume name +Steps: +- create a malloc bdev +- construct_lvol_store on created malloc bdev +- check correct uuid values in response from get_lvol_stores command +- destroy_lvol_store +- check correct response from get_lvol_stores command +- delete malloc bdev + +Expected result: +- calls successful, return code = 0 +- get_lvol_stores: response should be of no value after destroyed lvol store +- no other operation fails + +#### TEST CASE 9 - Name: destroy_lvol_store_with_lvol_bdev_positive Positive test for destroying a logical volume store with lvol bdev created on top. Call destroy_lvol_store with correct logical_volumes name @@ -143,7 +200,7 @@ Expected result: - get_lvol_stores: response should be of no value after destroyed lvol store - no other operation fails -#### TEST CASE 7 - Name: destroy_multi_logical_volumes_positive +#### TEST CASE 10 - Name: destroy_multi_logical_volumes_positive Positive test for destroying a logical volume store with multiple lvol bdevs created on top. Call construct_lvol_bdev with correct lvol store UUID and @@ -167,7 +224,7 @@ Expected result: ### nested_construct_logical_volume - positive tests -#### TEST CASE 8 - Name: nested_construct_logical_volume_positive +#### TEST CASE 11 - Name: nested_construct_logical_volume_positive Positive test for constructing a nested new lvol store. Call construct_lvol_store with correct base bdev name. Steps: @@ -196,7 +253,7 @@ Expected result: ### destroy_lvol_store - positive tests -#### TEST CASE 9 - Name: destroy_resize_logical_volume_positive +#### TEST CASE 12 - Name: destroy_resize_logical_volume_positive Positive test for destroying a logical_volume after resizing. Call destroy_lvol_store with correct logical_volumes name. Steps: @@ -225,7 +282,7 @@ Expected result: ### construct_lvol_store - negative tests -#### TEST CASE 10 - Name: construct_lvs_nonexistent_bdev +#### TEST CASE 13 - Name: construct_lvs_nonexistent_bdev Negative test for constructing a new lvol store. Call construct_lvol_store with base bdev name which does not exist in configuration. @@ -236,7 +293,7 @@ Expected result: - return code != 0 - Error code: ENODEV ("No such device") response printed to stdout -#### TEST CASE 11 - Name: construct_lvs_on_bdev_twice +#### TEST CASE 14 - Name: construct_lvs_on_bdev_twice Negative test for constructing a new lvol store. Call construct_lvol_store with base bdev name twice. Steps: @@ -254,9 +311,28 @@ Expected result: - EEXIST response printed to stdout - no other operation fails +#### TEST CASE 15 - Name: construct_lvs_name_twice +Negative test for constructing a new lvol store using the same +friendly name twice. +Steps: +- create two malloc bdevs +- create logical volume store on first malloc bdev +- using get_lvol_stores verify that logical volume store was correctly created + and has arguments as provided in step earlier (cluster size, friendly name, base bdev) +- try to create another logical volume store on second malloc bdev using the + same friendly name as before; this step is expected to fail as lvol stores + cannot have the same name +- delete existing lvol store +- delete malloc bdevs + +Expected results: +- creating two logical volume stores with the same friendly name should +not be possible +- no other operation fails + ### construct_lvol_bdev - negative tests -#### TEST CASE 12 - Name: construct_logical_volume_nonexistent_lvs_uuid +#### TEST CASE 16 - Name: construct_logical_volume_nonexistent_lvs_uuid Negative test for constructing a new logical_volume. Call construct_lvol_bdev with lvs_uuid which does not exist in configuration. @@ -267,7 +343,7 @@ Expected result: - return code != 0 - ENODEV response printed to stdout -#### TEST CASE 13 - Name: construct_lvol_bdev_on_full_lvol_store +#### TEST CASE 17 - Name: construct_lvol_bdev_on_full_lvol_store Negative test for constructing a new lvol bdev. Call construct_lvol_bdev on a full lvol store. Steps: @@ -287,9 +363,29 @@ Expected result: - EEXIST response printed to stdout - no other operation fails +#### TEST CASE 18 - Name: construct_lvol_bdev_name_twice +Negative test for constructing lvol bdev using the same +friendly name twice on the same logical volume store. +Steps: +- create malloc bdev +- create logical volume store on malloc bdev +- using get_lvol_stores verify that logical volume store was correctly created + and has arguments as provided in step earlier (cluster size, friendly name, base bdev) +- construct logical volume on lvol store and verify it was correctly created +- try to create another logical volume on the same lvol store using +the same friendly name as in previous step; this step should fail +- delete existing lvol bdev +- delete existing lvol store +- delete malloc bdevs + +Expected results: +- creating two logical volumes with the same friendly name within the same + lvol store should not be possible +- no other operation fails + ### resize_lvol_store - negative tests -#### TEST CASE 14 - Name: resize_logical_volume_nonexistent_logical_volume +#### TEST CASE 19 - Name: resize_logical_volume_nonexistent_logical_volume Negative test for resizing a logical_volume. Call resize_lvol_bdev with logical volume which does not exist in configuration. @@ -300,7 +396,7 @@ Expected result: - return code != 0 - Error code: ENODEV ("No such device") response printed to stdout -#### TEST CASE 15 - Name: resize_logical_volume_with_size_out_of_range +#### TEST CASE 20 - Name: resize_logical_volume_with_size_out_of_range Negative test for resizing a logical volume. Call resize_lvol_store with size argument bigger than size of base bdev. Steps: @@ -323,7 +419,7 @@ Expected result: ### destroy_lvol_store - negative tests -#### TEST CASE 16 - Name: destroy_lvol_store_nonexistent_lvs_uuid +#### TEST CASE 21 - Name: destroy_lvol_store_nonexistent_lvs_uuid Call destroy_lvol_store with nonexistent logical_volumes name exist in configuration. Steps: @@ -333,7 +429,7 @@ Expected result: - return code != 0 - Error code response printed to stdout -#### TEST CASE 17 - Name: delete_lvol_store_underlying_bdev +#### TEST CASE 22 - Name: delete_lvol_store_underlying_bdev Call destroy_lvol_store after deleting it's base bdev. Lvol store should be automatically removed on deleting underlying bdev. Steps: @@ -351,7 +447,7 @@ Expected result: ### nested construct_lvol_bdev - test negative -#### TEST CASE 18 - Name: nested_construct_lvol_bdev_on_full_lvol_store +#### TEST CASE 23 - Name: nested_construct_lvol_bdev_on_full_lvol_store Negative test for constructing a new nested lvol bdev. Call construct_lvol_bdev on a full lvol store. Steps: @@ -379,7 +475,7 @@ Expected result: ### destroy_lvol_store - negative tests -#### TEST CASE 19 - Name: nested_destroy_logical_volume_negative +#### TEST CASE 24 - Name: nested_destroy_logical_volume_negative Negative test for destroying a nested first lvol store. Call destroy_lvol_store with correct base bdev name. Steps: @@ -401,7 +497,7 @@ Expected result: ### delete_bdev - positive tests -#### TEST CASE 20 - Name: delete_bdev_positive +#### TEST CASE 25 - Name: delete_bdev_positive Positive test for deleting malloc bdev. Call construct_lvol_store with correct base bdev name. Steps: @@ -417,7 +513,7 @@ Expected result: ### construct_lvol_store_with_cluster_size - negative tests -#### TEST CASE 21 - Name: construct_lvol_store_with_cluster_size_max +#### TEST CASE 26 - Name: construct_lvol_store_with_cluster_size_max Negative test for constructing a new lvol store. Call construct_lvol_store with cluster size is equal malloc bdev size + 1B. Steps: @@ -429,7 +525,7 @@ Expected result: - return code != 0 - Error code response printed to stdout -#### TEST CASE 22 - Name: construct_lvol_store_with_cluster_size_min +#### TEST CASE 27 - Name: construct_lvol_store_with_cluster_size_min Negative test for constructing a new lvol store. Call construct_lvol_store with cluster size = 0. Steps: @@ -442,7 +538,7 @@ Expected result: ### logical volume tasting tests -#### TEST CASE 23 - Name: tasting_positive +#### TEST CASE 28 - Name: tasting_positive Positive test for tasting a multi lvol bdev configuration. Create a lvol store with some lvol bdevs on NVMe drive and restart vhost app. After restarting configuration should be automatically loaded and should be exactly @@ -485,7 +581,7 @@ Expected results: - no other operation fails ### SIGTERM -#### TEST CASE 24 - Name: SIGTERM +#### TEST CASE 29 - Name: SIGTERM Call CTRL+C (SIGTERM) occurs after creating lvol store Steps: - create a malloc bdev