d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

test/lvol: add friendly name specific tests

Browse Source 
Adding positive and negative lvol friendly names specific tests.
Test plan updated.
Also fix some test naming discrepancies between plan and
script while at it

Change-Id: Ifb1a62d6a231f4f4ebfb5bb6178d941fc2b9770d
Signed-off-by: Karol Latecki <karol.latecki@intel.com>
Reviewed-on: https://review.gerrithub.io/385552
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: Maciej Szwed <maciej.szwed@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
This commit is contained in:
Karol Latecki 2017-11-02 15:07:51 +01:00 committed by Daniel Verkamp
parent 3a6f8dc856
commit bc6540ad05
3 changed files with 327 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
autotest.sh
View File

@ -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

287
test/lvol/test_cases.py
View File

@ -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

138
test/lvol/test_plan.md
View File

@ -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