diff --git a/engine/storage/datamotion/src/test/java/org/apache/cloudstack/storage/motion/StorageSystemDataMotionStrategyTest.java b/engine/storage/datamotion/src/test/java/org/apache/cloudstack/storage/motion/StorageSystemDataMotionStrategyTest.java
index 45357fa64b2..fc51eeba7b6 100644
--- a/engine/storage/datamotion/src/test/java/org/apache/cloudstack/storage/motion/StorageSystemDataMotionStrategyTest.java
+++ b/engine/storage/datamotion/src/test/java/org/apache/cloudstack/storage/motion/StorageSystemDataMotionStrategyTest.java
@@ -369,4 +369,286 @@ public class StorageSystemDataMotionStrategyTest {
 
         assertFalse(strategy.isStoragePoolTypeInList(StoragePoolType.SharedMountPoint, listTypes));
     }
+
+    /**
+     * Test updateMigrateDiskInfoForBlockDevice with CLVM destination pool
+     * Should set driver type to RAW for CLVM
+     */
+    @Test
+    public void testUpdateMigrateDiskInfoForBlockDevice_ClvmDestination() {
+        MigrateCommand.MigrateDiskInfo originalDiskInfo = new MigrateCommand.MigrateDiskInfo(
+                "serial123",
+                MigrateCommand.MigrateDiskInfo.DiskType.FILE,
+                MigrateCommand.MigrateDiskInfo.DriverType.QCOW2,
+                MigrateCommand.MigrateDiskInfo.Source.FILE,
+                "/source/path",
+                null
+        );
+
+        StoragePoolVO destStoragePool = new StoragePoolVO();
+        destStoragePool.setPoolType(StoragePoolType.CLVM);
+
+        MigrateCommand.MigrateDiskInfo updatedDiskInfo = strategy.updateMigrateDiskInfoForBlockDevice(
+                originalDiskInfo, destStoragePool);
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, updatedDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.RAW, updatedDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, updatedDiskInfo.getSource());
+        Assert.assertEquals("serial123", updatedDiskInfo.getSerialNumber());
+        Assert.assertEquals("/source/path", updatedDiskInfo.getSourceText());
+    }
+
+    /**
+     * Test updateMigrateDiskInfoForBlockDevice with CLVM_NG destination pool
+     * Should set driver type to QCOW2 for CLVM_NG
+     */
+    @Test
+    public void testUpdateMigrateDiskInfoForBlockDevice_ClvmNgDestination() {
+        MigrateCommand.MigrateDiskInfo originalDiskInfo = new MigrateCommand.MigrateDiskInfo(
+                "serial456",
+                MigrateCommand.MigrateDiskInfo.DiskType.FILE,
+                MigrateCommand.MigrateDiskInfo.DriverType.RAW,
+                MigrateCommand.MigrateDiskInfo.Source.FILE,
+                "/source/path",
+                "/backing/path"
+        );
+
+        StoragePoolVO destStoragePool = new StoragePoolVO();
+        destStoragePool.setPoolType(StoragePoolType.CLVM_NG);
+
+        MigrateCommand.MigrateDiskInfo updatedDiskInfo = strategy.updateMigrateDiskInfoForBlockDevice(
+                originalDiskInfo, destStoragePool);
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, updatedDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.QCOW2, updatedDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, updatedDiskInfo.getSource());
+        Assert.assertEquals("serial456", updatedDiskInfo.getSerialNumber());
+        Assert.assertEquals("/source/path", updatedDiskInfo.getSourceText());
+        Assert.assertEquals("/backing/path", updatedDiskInfo.getBackingStoreText());
+    }
+
+    /**
+     * Test updateMigrateDiskInfoForBlockDevice with non-CLVM destination pool
+     * Should return original DiskInfo unchanged
+     */
+    @Test
+    public void testUpdateMigrateDiskInfoForBlockDevice_NonClvmDestination() {
+        MigrateCommand.MigrateDiskInfo originalDiskInfo = new MigrateCommand.MigrateDiskInfo(
+                "serial789",
+                MigrateCommand.MigrateDiskInfo.DiskType.FILE,
+                MigrateCommand.MigrateDiskInfo.DriverType.QCOW2,
+                MigrateCommand.MigrateDiskInfo.Source.FILE,
+                "/source/path",
+                null
+        );
+
+        StoragePoolVO destStoragePool = new StoragePoolVO();
+        destStoragePool.setPoolType(StoragePoolType.NetworkFilesystem);
+
+        MigrateCommand.MigrateDiskInfo updatedDiskInfo = strategy.updateMigrateDiskInfoForBlockDevice(
+                originalDiskInfo, destStoragePool);
+
+        Assert.assertSame(originalDiskInfo, updatedDiskInfo);
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.FILE, updatedDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.QCOW2, updatedDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.FILE, updatedDiskInfo.getSource());
+    }
+
+    /**
+     * Test supportStoragePoolType with CLVM and CLVM_NG types
+     */
+    @Test
+    public void testSupportStoragePoolType_ClvmTypes() {
+        assertTrue(strategy.supportStoragePoolType(StoragePoolType.CLVM, StoragePoolType.CLVM, StoragePoolType.CLVM_NG));
+        assertTrue(strategy.supportStoragePoolType(StoragePoolType.CLVM_NG, StoragePoolType.CLVM, StoragePoolType.CLVM_NG));
+
+        assertFalse(strategy.supportStoragePoolType(StoragePoolType.CLVM));
+        assertFalse(strategy.supportStoragePoolType(StoragePoolType.CLVM_NG));
+    }
+
+    /**
+     * Test configureMigrateDiskInfo with CLVM destination
+     */
+    @Test
+    public void testConfigureMigrateDiskInfo_ForClvm() {
+        VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn("/dev/vg/volume-path").when(srcVolumeInfo).getPath();
+
+        MigrateCommand.MigrateDiskInfo migrateDiskInfo = strategy.configureMigrateDiskInfo(
+                srcVolumeInfo, "/dev/vg/dest-path", null);
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, migrateDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.RAW, migrateDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, migrateDiskInfo.getSource());
+        Assert.assertEquals("/dev/vg/dest-path", migrateDiskInfo.getSourceText());
+        Assert.assertEquals("/dev/vg/volume-path", migrateDiskInfo.getSerialNumber());
+    }
+
+    /**
+     * Test configureMigrateDiskInfo with CLVM_NG destination and backing file
+     */
+    @Test
+    public void testConfigureMigrateDiskInfo_ForClvmNgWithBacking() {
+        VolumeObject srcVolumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn("/dev/vg/volume-path").when(srcVolumeInfo).getPath();
+
+        MigrateCommand.MigrateDiskInfo migrateDiskInfo = strategy.configureMigrateDiskInfo(
+                srcVolumeInfo, "/dev/vg/dest-path", "/dev/vg/backing-template");
+
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DiskType.BLOCK, migrateDiskInfo.getDiskType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.DriverType.RAW, migrateDiskInfo.getDriverType());
+        Assert.assertEquals(MigrateCommand.MigrateDiskInfo.Source.DEV, migrateDiskInfo.getSource());
+        Assert.assertEquals("/dev/vg/dest-path", migrateDiskInfo.getSourceText());
+        Assert.assertEquals("/dev/vg/backing-template", migrateDiskInfo.getBackingStoreText());
+        Assert.assertEquals("/dev/vg/volume-path", migrateDiskInfo.getSerialNumber());
+    }
+
+    /**
+     * Test isStoragePoolTypeInList with CLVM types
+     */
+    @Test
+    public void testIsStoragePoolTypeInList_WithClvmTypes() {
+        StoragePoolType[] clvmTypes = new StoragePoolType[] {
+            StoragePoolType.CLVM,
+            StoragePoolType.CLVM_NG,
+            StoragePoolType.Filesystem
+        };
+
+        assertTrue(strategy.isStoragePoolTypeInList(StoragePoolType.CLVM, clvmTypes));
+        assertTrue(strategy.isStoragePoolTypeInList(StoragePoolType.CLVM_NG, clvmTypes));
+        assertTrue(strategy.isStoragePoolTypeInList(StoragePoolType.Filesystem, clvmTypes));
+        assertFalse(strategy.isStoragePoolTypeInList(StoragePoolType.NetworkFilesystem, clvmTypes));
+    }
+
+    /**
+     * Test supportStoragePoolType with mixed CLVM and NFS types
+     */
+    @Test
+    public void testSupportStoragePoolType_MixedClvmAndNfs() {
+        assertTrue(strategy.supportStoragePoolType(
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM_NG,
+                StoragePoolType.NetworkFilesystem
+        ));
+
+        assertTrue(strategy.supportStoragePoolType(
+                StoragePoolType.CLVM_NG,
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM_NG,
+                StoragePoolType.NetworkFilesystem
+        ));
+
+        assertTrue(strategy.supportStoragePoolType(
+                StoragePoolType.NetworkFilesystem,
+                StoragePoolType.CLVM,
+                StoragePoolType.CLVM_NG
+        ));
+    }
+
+    /**
+     * Test internalCanHandle with CLVM source and managed destination
+     */
+    @Test
+    public void testInternalCanHandle_ClvmSourceManagedDestination() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
+
+    /**
+     * Test internalCanHandle with CLVM_NG source and managed destination
+     */
+    @Test
+    public void testInternalCanHandle_ClvmNgSourceManagedDestination() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM_NG).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
+
+    /**
+     * Test internalCanHandle with both CLVM source and CLVM_NG destination
+     */
+    @Test
+    public void testInternalCanHandle_ClvmToClvmNg() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        StoragePoolVO destPool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM_NG).when(destPool).getPoolType();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
+
+    /**
+     * Test internalCanHandle with CLVM_NG to CLVM migration
+     */
+    @Test
+    public void testInternalCanHandle_ClvmNgToClvm() {
+        VolumeObject volumeInfo = Mockito.spy(new VolumeObject());
+        Mockito.doReturn(0L).when(volumeInfo).getPoolId();
+
+        DataStore ds = Mockito.spy(new PrimaryDataStoreImpl());
+
+        Map<VolumeInfo, DataStore> volumeMap = new HashMap<>();
+        volumeMap.put(volumeInfo, ds);
+
+        StoragePoolVO sourcePool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM_NG).when(sourcePool).getPoolType();
+        Mockito.doReturn(true).when(sourcePool).isManaged();
+
+        StoragePoolVO destPool = Mockito.spy(new StoragePoolVO());
+        Mockito.lenient().doReturn(StoragePoolType.CLVM).when(destPool).getPoolType();
+
+        Mockito.doReturn(sourcePool).when(primaryDataStoreDao).findById(0L);
+
+        StrategyPriority result = strategy.internalCanHandle(
+                volumeMap, new HostVO("srcHostUuid"), new HostVO("destHostUuid"));
+
+        Assert.assertEquals(StrategyPriority.HIGHEST, result);
+    }
 }
diff --git a/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/DefaultVMSnapshotStrategyTest.java b/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/DefaultVMSnapshotStrategyTest.java
index da377f96ec3..365ba3d4eb3 100644
--- a/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/DefaultVMSnapshotStrategyTest.java
+++ b/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/DefaultVMSnapshotStrategyTest.java
@@ -22,6 +22,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
+import org.apache.cloudstack.engine.subsystem.api.storage.StrategyPriority;
 import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
 import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
 import org.apache.cloudstack.storage.to.VolumeObjectTO;
@@ -39,6 +40,10 @@ import com.cloud.storage.Storage;
 import com.cloud.storage.Volume;
 import com.cloud.storage.VolumeVO;
 import com.cloud.storage.dao.VolumeDao;
+import com.cloud.vm.UserVmVO;
+import com.cloud.vm.VirtualMachine.State;
+import com.cloud.vm.dao.UserVmDao;
+import com.cloud.vm.snapshot.VMSnapshot;
 
 @RunWith(MockitoJUnitRunner.class)
 public class DefaultVMSnapshotStrategyTest {
@@ -46,6 +51,8 @@ public class DefaultVMSnapshotStrategyTest {
     VolumeDao volumeDao;
     @Mock
     PrimaryDataStoreDao primaryDataStoreDao;
+    @Mock
+    UserVmDao userVmDao;
 
     @Spy
     @InjectMocks
@@ -85,7 +92,7 @@ public class DefaultVMSnapshotStrategyTest {
         Mockito.when(vol2.getChainInfo()).thenReturn(newVolChain);
         Mockito.when(vol2.getSize()).thenReturn(vmSnapshotChainSize);
         Mockito.when(vol2.getId()).thenReturn(volumeId);
-        VolumeVO volumeVO = new VolumeVO("name", 0l, 0l, 0l, 0l, 0l, "folder", "path", Storage.ProvisioningType.THIN, 0l, Volume.Type.ROOT);
+        VolumeVO volumeVO = new VolumeVO("name", 0L, 0L, 0L, 0L, 0L, "folder", "path", Storage.ProvisioningType.THIN, 0L, Volume.Type.ROOT);
         volumeVO.setPoolId(oldPoolId);
         volumeVO.setChainInfo(oldVolChain);
         volumeVO.setPath(oldVolPath);
@@ -103,4 +110,110 @@ public class DefaultVMSnapshotStrategyTest {
         Assert.assertEquals(vmSnapshotChainSize, persistedVolume.getVmSnapshotChainSize());
         Assert.assertEquals(newVolChain, persistedVolume.getChainInfo());
     }
+
+    @Test
+    public void testCanHandleRunningVMOnClvmStorageCantHandle() {
+        Long vmId = 1L;
+        VMSnapshot vmSnapshot = Mockito.mock(VMSnapshot.class);
+        Mockito.when(vmSnapshot.getVmId()).thenReturn(vmId);
+
+        UserVmVO vm = Mockito.mock(UserVmVO.class);
+        Mockito.when(vm.getId()).thenReturn(vmId);
+        Mockito.when(vm.getState()).thenReturn(State.Running);
+        Mockito.when(userVmDao.findById(vmId)).thenReturn(vm);
+
+        VolumeVO volumeOnClvm = createVolume(vmId, 1L);
+        List<VolumeVO> volumes = List.of(volumeOnClvm);
+        Mockito.when(volumeDao.findByInstance(vmId)).thenReturn(volumes);
+
+        StoragePoolVO clvmPool = createStoragePool("clvm-pool", Storage.StoragePoolType.CLVM);
+        Mockito.when(primaryDataStoreDao.findById(1L)).thenReturn(clvmPool);
+
+        StrategyPriority result = defaultVMSnapshotStrategy.canHandle(vmSnapshot);
+
+        Assert.assertEquals("Should return CANT_HANDLE for running VM on CLVM storage",
+                StrategyPriority.CANT_HANDLE, result);
+    }
+
+    @Test
+    public void testCanHandleStoppedVMOnClvmStorageCanHandle() {
+        Long vmId = 1L;
+        VMSnapshot vmSnapshot = Mockito.mock(VMSnapshot.class);
+        Mockito.when(vmSnapshot.getVmId()).thenReturn(vmId);
+
+        UserVmVO vm = Mockito.mock(UserVmVO.class);
+        Mockito.when(vm.getId()).thenReturn(vmId);
+        Mockito.when(vm.getState()).thenReturn(State.Stopped);
+        Mockito.when(userVmDao.findById(vmId)).thenReturn(vm);
+
+        StrategyPriority result = defaultVMSnapshotStrategy.canHandle(vmSnapshot);
+        Assert.assertEquals("Should return DEFAULT for stopped VM on CLVM storage",
+                StrategyPriority.DEFAULT, result);
+    }
+
+    @Test
+    public void testCanHandleRunningVMOnNfsStorageCanHandle() {
+        Long vmId = 1L;
+        VMSnapshot vmSnapshot = Mockito.mock(VMSnapshot.class);
+        Mockito.when(vmSnapshot.getVmId()).thenReturn(vmId);
+
+        UserVmVO vm = Mockito.mock(UserVmVO.class);
+        Mockito.when(vm.getId()).thenReturn(vmId);
+        Mockito.when(vm.getState()).thenReturn(State.Running);
+        Mockito.when(userVmDao.findById(vmId)).thenReturn(vm);
+
+        VolumeVO volumeOnNfs = createVolume(vmId, 1L);
+        List<VolumeVO> volumes = List.of(volumeOnNfs);
+        Mockito.when(volumeDao.findByInstance(vmId)).thenReturn(volumes);
+
+        StoragePoolVO nfsPool = createStoragePool("nfs-pool", Storage.StoragePoolType.NetworkFilesystem);
+        Mockito.when(primaryDataStoreDao.findById(1L)).thenReturn(nfsPool);
+
+        StrategyPriority result = defaultVMSnapshotStrategy.canHandle(vmSnapshot);
+
+        Assert.assertEquals("Should return DEFAULT for running VM on NFS storage",
+                StrategyPriority.DEFAULT, result);
+    }
+
+    @Test
+    public void testCanHandleRunningVMWithMixedStorageClvmAndNfsCantHandle() {
+        // Arrange - VM has volumes on both CLVM and NFS
+        Long vmId = 1L;
+        VMSnapshot vmSnapshot = Mockito.mock(VMSnapshot.class);
+        Mockito.when(vmSnapshot.getVmId()).thenReturn(vmId);
+
+        UserVmVO vm = Mockito.mock(UserVmVO.class);
+        Mockito.when(vm.getId()).thenReturn(vmId);
+        Mockito.when(vm.getState()).thenReturn(State.Running);
+        Mockito.when(userVmDao.findById(vmId)).thenReturn(vm);
+
+        VolumeVO volumeOnClvm = createVolume(vmId, 1L);
+        VolumeVO volumeOnNfs = createVolume(vmId, 2L);
+        List<VolumeVO> volumes = List.of(volumeOnClvm, volumeOnNfs);
+        Mockito.when(volumeDao.findByInstance(vmId)).thenReturn(volumes);
+
+        StoragePoolVO clvmPool = createStoragePool("clvm-pool", Storage.StoragePoolType.CLVM);
+        StoragePoolVO nfsPool = createStoragePool("nfs-pool", Storage.StoragePoolType.NetworkFilesystem);
+        Mockito.when(primaryDataStoreDao.findById(1L)).thenReturn(clvmPool);
+
+        StrategyPriority result = defaultVMSnapshotStrategy.canHandle(vmSnapshot);
+
+        Assert.assertEquals("Should return CANT_HANDLE if any volume is on CLVM storage for running VM",
+                StrategyPriority.CANT_HANDLE, result);
+    }
+
+    private VolumeVO createVolume(Long vmId, Long poolId) {
+        VolumeVO volume = new VolumeVO("volume", 0L, 0L, 0L, 0L, 0L,
+                "folder", "path", Storage.ProvisioningType.THIN, 0L, Volume.Type.ROOT);
+        volume.setInstanceId(vmId);
+        volume.setPoolId(poolId);
+        return volume;
+    }
+
+    private StoragePoolVO createStoragePool(String name, Storage.StoragePoolType poolType) {
+        StoragePoolVO pool = Mockito.mock(StoragePoolVO.class);
+        Mockito.when(pool.getName()).thenReturn(name);
+        Mockito.when(pool.getPoolType()).thenReturn(poolType);
+        return pool;
+    }
 }
diff --git a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResourceTest.java b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResourceTest.java
index 8d343d4c0e4..fbadf1c5078 100644
--- a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResourceTest.java
+++ b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResourceTest.java
@@ -7209,4 +7209,305 @@ public class LibvirtComputingResourceTest {
         libvirtComputingResourceSpy.defineDiskForDefaultPoolType(diskDef, volume, false, false, false, physicalDisk, DEV_ID, DISK_BUS_TYPE, DISK_BUS_TYPE_DATA, null);
         Mockito.verify(diskDef).defFileBasedDisk(PHYSICAL_DISK_PATH, DEV_ID, DISK_BUS_TYPE_DATA, DiskDef.DiskFmtType.QCOW2);
     }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_ValidPath() {
+        String devicePath = "/dev/vg1/volume-123";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("vg1", vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_ComplexVGName() {
+        String devicePath = "/dev/cloudstack-vg-primary/volume-456";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("cloudstack-vg-primary", vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_MultiLevelPath() {
+        String devicePath = "/dev/vg-cluster-01/lv-data-001";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("vg-cluster-01", vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_NullPath() {
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(null);
+        assertNull(vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_EmptyPath() {
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath("");
+        assertNull(vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_NonDevPath() {
+        String devicePath = "/var/lib/libvirt/images/disk.qcow2";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertNull(vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_InvalidFormat() {
+        String devicePath = "/dev/";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertNull(vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_OnlyVG() {
+        String devicePath = "/dev/vg1";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        // Implementation extracts parts[2] regardless of whether there's an LV name
+        assertEquals("vg1", vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_MapperPath() {
+        String devicePath = "/dev/mapper/vg1-volume";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("mapper", vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_WithDashes() {
+        String devicePath = "/dev/vg-name-with-dashes/lv-name";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("vg-name-with-dashes", vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_WithUnderscores() {
+        String devicePath = "/dev/vg_name_with_underscores/lv_name";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("vg_name_with_underscores", vgName);
+    }
+
+    @Test
+    public void testCheckIfVolumeGroupIsClustered_NullVGName() {
+        boolean result = LibvirtComputingResource.checkIfVolumeGroupIsClustered(null);
+        assertFalse(result);
+    }
+
+    @Test
+    public void testCheckIfVolumeGroupIsClustered_EmptyVGName() {
+        boolean result = LibvirtComputingResource.checkIfVolumeGroupIsClustered("");
+        assertFalse(result);
+    }
+
+    @Test
+    public void testActivateClvmVolumeExclusive_ValidPath() {
+        try {
+            String volumePath = "/dev/test-vg/test-lv";
+            LibvirtComputingResource.activateClvmVolumeExclusive(volumePath);
+        } catch (Exception e) {
+            String message = e.getMessage().toLowerCase();
+            assertTrue("Should be LVM-related error",
+                message.contains("lvm") ||
+                message.contains("lvchange") ||
+                message.contains("volume") ||
+                message.contains("not found") ||
+                message.contains("failed"));
+        }
+    }
+
+    @Test
+    public void testDeactivateClvmVolume_ValidPath() {
+        String volumePath = "/dev/test-vg/test-lv";
+
+        LibvirtComputingResource.deactivateClvmVolume(volumePath);
+
+        assertTrue(true);
+    }
+
+    @Test
+    public void testSetClvmVolumeToSharedMode_ValidPath() {
+        String volumePath = "/dev/test-vg/test-lv";
+
+        LibvirtComputingResource.setClvmVolumeToSharedMode(volumePath);
+
+        assertTrue(true);
+    }
+
+    @Test
+    public void testDeactivateClvmVolume_NullPath() {
+        LibvirtComputingResource.deactivateClvmVolume(null);
+        assertTrue(true);
+    }
+
+    @Test
+    public void testSetClvmVolumeToSharedMode_NullPath() {
+        LibvirtComputingResource.setClvmVolumeToSharedMode(null);
+        assertTrue(true); // Passes if no exception
+    }
+
+    @Test
+    public void testDeactivateClvmVolume_EmptyPath() {
+        LibvirtComputingResource.deactivateClvmVolume("");
+        assertTrue(true);
+    }
+
+    @Test
+    public void testSetClvmVolumeToSharedMode_EmptyPath() {
+        LibvirtComputingResource.setClvmVolumeToSharedMode("");
+        assertTrue(true);
+    }
+
+    @Test
+    public void testDeactivateClvmVolume_InvalidPath() {
+        String invalidPath = "/invalid/path/that/does/not/exist";
+        LibvirtComputingResource.deactivateClvmVolume(invalidPath);
+        assertTrue(true);
+    }
+
+    @Test
+    public void testSetClvmVolumeToSharedMode_InvalidPath() {
+        // Should handle invalid path gracefully without throwing
+        String invalidPath = "/invalid/path/that/does/not/exist";
+        LibvirtComputingResource.setClvmVolumeToSharedMode(invalidPath);
+        assertTrue(true); // Passes if no exception
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_RealWorldPaths() {
+        assertEquals("acsvg", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/acsvg/volume-123"));
+        assertEquals("cloudstack-primary", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/cloudstack-primary/vm-disk-1"));
+        assertEquals("ceph-vg", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/ceph-vg/snapshot-456"));
+        assertEquals("vg01", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/vg01/data"));
+    }
+
+    @Test
+    public void testCheckIfVolumeGroupIsClustered_NonExistentVG() {
+        String nonExistentVG = "non-existent-vg-" + System.currentTimeMillis();
+        boolean result = LibvirtComputingResource.checkIfVolumeGroupIsClustered(nonExistentVG);
+        assertFalse(result);
+    }
+
+    @Test
+    public void testActivateClvmVolumeExclusive_ComplexPath() {
+        try {
+            String complexPath = "/dev/cloudstack-vg-primary-cluster-01/volume-123-456-789-abc";
+            LibvirtComputingResource.activateClvmVolumeExclusive(complexPath);
+        } catch (Exception e) {
+            String message = e.getMessage().toLowerCase();
+            assertTrue("Should be LVM-related error",
+                message.contains("lvm") ||
+                message.contains("lvchange") ||
+                message.contains("volume") ||
+                message.contains("not found") ||
+                message.contains("failed"));
+        }
+    }
+
+    @Test
+    public void testDeactivateClvmVolume_ComplexPath() {
+        String complexPath = "/dev/cloudstack-vg-primary-cluster-01/volume-123-456-789-abc";
+        LibvirtComputingResource.deactivateClvmVolume(complexPath);
+        assertTrue(true);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_SpecialCharacters() {
+        assertEquals("vg.name", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/vg.name/lv"));
+        assertEquals("vg_name", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/vg_name/lv"));
+        assertEquals("vg-name", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/vg-name/lv"));
+        assertEquals("vg123", LibvirtComputingResource.extractVolumeGroupFromPath("/dev/vg123/lv456"));
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_TrailingSlash() {
+        String devicePath = "/dev/vg1/volume-123/";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("vg1", vgName);
+    }
+
+    @Test
+    public void testCheckIfVolumeGroupIsClustered_WhitespaceVGName() {
+        boolean result = LibvirtComputingResource.checkIfVolumeGroupIsClustered("   ");
+        assertFalse(result);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_DevMapperExcluded() {
+        String mapperPath1 = "/dev/mapper/vg1-lv1";
+        String mapperPath2 = "/dev/mapper/cloudstack--vg-volume--1";
+
+        assertEquals("mapper", LibvirtComputingResource.extractVolumeGroupFromPath(mapperPath1));
+        assertEquals("mapper", LibvirtComputingResource.extractVolumeGroupFromPath(mapperPath2));
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_EdgeCases() {
+        assertNull(LibvirtComputingResource.extractVolumeGroupFromPath("/dev"));
+        assertNull(LibvirtComputingResource.extractVolumeGroupFromPath("/dev/"));
+        assertNull(LibvirtComputingResource.extractVolumeGroupFromPath("dev/vg/lv"));
+        assertNull(LibvirtComputingResource.extractVolumeGroupFromPath("//dev//vg//lv"));
+    }
+
+    @Test
+    public void testClvmVolumeActivationSequence() {
+        // Test a typical sequence: deactivate -> activate exclusive -> deactivate -> shared
+        String volumePath = "/dev/test-vg/test-volume";
+
+        LibvirtComputingResource.deactivateClvmVolume(volumePath);
+
+        try {
+            LibvirtComputingResource.activateClvmVolumeExclusive(volumePath);
+        } catch (Exception e) {
+            // Expected in test environment
+        }
+
+        LibvirtComputingResource.deactivateClvmVolume(volumePath);
+        LibvirtComputingResource.setClvmVolumeToSharedMode(volumePath);
+
+        assertTrue(true); // Test passes if sequence completes
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_LongVGName() {
+        String longVGName = "a".repeat(100);
+        String devicePath = "/dev/" + longVGName + "/volume";
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals(longVGName, vgName);
+    }
+
+    @Test
+    public void testExtractVolumeGroupFromPath_LongLVName() {
+        String longLVName = "volume-" + "b".repeat(100);
+        String devicePath = "/dev/vg1/" + longLVName;
+        String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(devicePath);
+        assertEquals("vg1", vgName);
+    }
+
+    @Test
+    public void testCheckIfVolumeGroupIsClustered_SpecialCharactersInName() {
+        assertFalse(LibvirtComputingResource.checkIfVolumeGroupIsClustered("vg.test.name"));
+        assertFalse(LibvirtComputingResource.checkIfVolumeGroupIsClustered("vg_test_name"));
+        assertFalse(LibvirtComputingResource.checkIfVolumeGroupIsClustered("vg-test-name"));
+    }
+
+    @Test
+    public void testClvmMethodsWithMultiplePaths() {
+        String[] paths = {
+            "/dev/vg1/vol1",
+            "/dev/vg2/vol2",
+            "/dev/cloudstack-primary/vol3",
+            "/dev/test-vg/test-vol"
+        };
+
+        for (String path : paths) {
+            LibvirtComputingResource.deactivateClvmVolume(path);
+            LibvirtComputingResource.setClvmVolumeToSharedMode(path);
+
+            String vgName = LibvirtComputingResource.extractVolumeGroupFromPath(path);
+            assertNotNull("Should extract VG from: " + path, vgName);
+
+            boolean clustered = LibvirtComputingResource.checkIfVolumeGroupIsClustered(vgName);
+        }
+
+        assertTrue(true); // Passes if all paths processed
+    }
 }
diff --git a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtClvmLockTransferCommandWrapperTest.java b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtClvmLockTransferCommandWrapperTest.java
new file mode 100644
index 00000000000..2d2d57d7500
--- /dev/null
+++ b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtClvmLockTransferCommandWrapperTest.java
@@ -0,0 +1,468 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package com.cloud.hypervisor.kvm.resource.wrapper;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.cloudstack.storage.command.ClvmLockTransferCommand;
+import org.apache.logging.log4j.Logger;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.hypervisor.kvm.resource.LibvirtComputingResource;
+import com.cloud.utils.script.Script;
+
+/**
+ * Tests for LibvirtClvmLockTransferCommandWrapper
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class LibvirtClvmLockTransferCommandWrapperTest {
+
+    @Mock
+    private LibvirtComputingResource libvirtComputingResource;
+
+    @Mock
+    private Logger logger;
+
+    private LibvirtClvmLockTransferCommandWrapper wrapper;
+
+    private static final String TEST_LV_PATH = "/dev/vg1/volume-123";
+    private static final String TEST_VOLUME_UUID = "test-volume-uuid-456";
+
+    @Before
+    public void setUp() {
+        wrapper = new LibvirtClvmLockTransferCommandWrapper();
+        wrapper.logger = logger;
+    }
+
+    @Test
+    public void testExecute_DeactivateSuccess() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null); // Success
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertTrue(answer.getResult());
+            assertTrue(answer.getDetails().contains("deactivated"));
+            assertTrue(answer.getDetails().contains(TEST_VOLUME_UUID));
+
+            // Verify script was constructed with correct parameters
+            assertEquals(1, scriptMock.constructed().size());
+            Script script = scriptMock.constructed().get(0);
+            verify(script).add("-an");
+            verify(script).add(TEST_LV_PATH);
+        }
+    }
+
+    @Test
+    public void testExecute_ActivateExclusiveSuccess() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_EXCLUSIVE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null); // Success
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertTrue(answer.getResult());
+            assertTrue(answer.getDetails().contains("activated exclusively"));
+            assertTrue(answer.getDetails().contains(TEST_VOLUME_UUID));
+
+            // Verify script was constructed with correct parameters
+            assertEquals(1, scriptMock.constructed().size());
+            Script script = scriptMock.constructed().get(0);
+            verify(script).add("-aey");
+            verify(script).add(TEST_LV_PATH);
+        }
+    }
+
+    @Test
+    public void testExecute_ActivateSharedSuccess() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_SHARED,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null); // Success
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertTrue(answer.getResult());
+            assertTrue(answer.getDetails().contains("activated in shared mode"));
+            assertTrue(answer.getDetails().contains(TEST_VOLUME_UUID));
+
+            // Verify script was constructed with correct parameters
+            assertEquals(1, scriptMock.constructed().size());
+            Script script = scriptMock.constructed().get(0);
+            verify(script).add("-asy");
+            verify(script).add(TEST_LV_PATH);
+        }
+    }
+
+    @Test
+    public void testExecute_LvchangeFailure() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        String errorMessage = "lvchange: Volume is in use";
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(errorMessage);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains("lvchange -an"));
+            assertTrue(answer.getDetails().contains(TEST_LV_PATH));
+            assertTrue(answer.getDetails().contains(errorMessage));
+        }
+    }
+
+    @Test
+    public void testExecute_ScriptTimeout() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_EXCLUSIVE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        String timeoutMessage = "Script timed out after 30000ms";
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(timeoutMessage);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains("failed"));
+            assertTrue(answer.getDetails().contains(timeoutMessage));
+        }
+    }
+
+    @Test
+    public void testExecute_NullLvPath() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                null,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            // Should still execute, but may fail or succeed depending on lvchange behavior
+            // At minimum, it should handle null gracefully
+            assertEquals(1, scriptMock.constructed().size());
+        }
+    }
+
+    @Test
+    public void testExecute_EmptyLvPath() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                "",
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn("lvchange: Please specify a logical volume path");
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains("failed"));
+        }
+    }
+
+    @Test
+    public void testExecute_InvalidLvPath() {
+        String invalidPath = "/invalid/path/that/does/not/exist";
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_EXCLUSIVE,
+                invalidPath,
+                TEST_VOLUME_UUID
+        );
+
+        String errorMessage = "Failed to find logical volume \"" + invalidPath + "\"";
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(errorMessage);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains("failed"));
+            assertTrue(answer.getDetails().contains(errorMessage));
+        }
+    }
+
+    @Test
+    public void testExecute_ExceptionDuringExecution() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        RuntimeException testException = new RuntimeException("Test exception");
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenThrow(testException);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains("Exception"));
+            assertTrue(answer.getDetails().contains("Test exception"));
+        }
+    }
+
+    @Test
+    public void testExecute_VerifyScriptConstruction() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    // Just set up the mock behavior - don't assert here as it can interfere
+                    when(mock.execute()).thenReturn(null);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            // Verify the answer is successful
+            assertNotNull("Answer should not be null", answer);
+            assertTrue("Answer should indicate success. Details: " + answer.getDetails(),
+                      answer.getResult());
+
+            // Verify that Script was constructed exactly once
+            assertEquals("Script should be constructed once", 1, scriptMock.constructed().size());
+        }
+    }
+
+    @Test
+    public void testExecute_AllOperationsUseDifferentFlags() {
+        // Test that each operation uses the correct lvchange flag
+
+        // DEACTIVATE -> -an
+        ClvmLockTransferCommand deactivateCmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null);
+                })) {
+
+            wrapper.execute(deactivateCmd, libvirtComputingResource);
+            verify(scriptMock.constructed().get(0)).add("-an");
+        }
+
+        // ACTIVATE_EXCLUSIVE -> -aey
+        ClvmLockTransferCommand exclusiveCmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_EXCLUSIVE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null);
+                })) {
+
+            wrapper.execute(exclusiveCmd, libvirtComputingResource);
+            verify(scriptMock.constructed().get(0)).add("-aey");
+        }
+
+        // ACTIVATE_SHARED -> -asy
+        ClvmLockTransferCommand sharedCmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_SHARED,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null);
+                })) {
+
+            wrapper.execute(sharedCmd, libvirtComputingResource);
+            verify(scriptMock.constructed().get(0)).add("-asy");
+        }
+    }
+
+    @Test
+    public void testExecute_LvchangeVolumeInUseError() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.DEACTIVATE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        String errorMessage = "Can't deactivate volume group with active logical volumes";
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(errorMessage);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains(errorMessage));
+        }
+    }
+
+    @Test
+    public void testExecute_LvchangePermissionDenied() {
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_EXCLUSIVE,
+                TEST_LV_PATH,
+                TEST_VOLUME_UUID
+        );
+
+        String errorMessage = "Permission denied";
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(errorMessage);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertFalse(answer.getResult());
+            assertTrue(answer.getDetails().contains(errorMessage));
+        }
+    }
+
+    @Test
+    public void testExecute_ComplexLvPath() {
+        String complexPath = "/dev/cloudstack-vg-primary/volume-123-456-789-abc-def";
+        ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                ClvmLockTransferCommand.Operation.ACTIVATE_EXCLUSIVE,
+                complexPath,
+                TEST_VOLUME_UUID
+        );
+
+        try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                (mock, context) -> {
+                    when(mock.execute()).thenReturn(null);
+                })) {
+
+            Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+            assertNotNull(answer);
+            assertTrue(answer.getResult());
+
+            // Verify the complex path was passed correctly
+            Script script = scriptMock.constructed().get(0);
+            verify(script).add(complexPath);
+        }
+    }
+
+    @Test
+    public void testExecute_SequentialOperations() {
+        // Test that multiple operations can be executed sequentially
+        String[] paths = {
+            "/dev/vg1/vol1",
+            "/dev/vg1/vol2",
+            "/dev/vg2/vol3"
+        };
+
+        for (String path : paths) {
+            ClvmLockTransferCommand cmd = new ClvmLockTransferCommand(
+                    ClvmLockTransferCommand.Operation.DEACTIVATE,
+                    path,
+                    "uuid-" + path.hashCode()
+            );
+
+            try (MockedConstruction<Script> scriptMock = Mockito.mockConstruction(Script.class,
+                    (mock, context) -> {
+                        when(mock.execute()).thenReturn(null);
+                    })) {
+
+                Answer answer = wrapper.execute(cmd, libvirtComputingResource);
+
+                assertNotNull(answer);
+                assertTrue(answer.getResult());
+            }
+        }
+    }
+}
+
diff --git a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java
index cfb7a113683..44331d1019d 100644
--- a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java
+++ b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java
@@ -27,6 +27,7 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.when;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.Map;
@@ -454,7 +455,7 @@ public class LibvirtStorageAdaptorTest {
 
         try {
             method.invoke(libvirtStorageAdaptor, volumeName, size, mockPool);
-        } catch (java.lang.reflect.InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
@@ -542,7 +543,7 @@ public class LibvirtStorageAdaptorTest {
         try {
             method.invoke(libvirtStorageAdaptor, volumeUuid, timeout, virtualSize,
                          null, mockPool, Storage.ProvisioningType.THIN);
-        } catch (java.lang.reflect.InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
@@ -578,7 +579,7 @@ public class LibvirtStorageAdaptorTest {
         try {
             method.invoke(libvirtStorageAdaptor, volumeUuid, timeout, virtualSize,
                          null, mockPool, Storage.ProvisioningType.THIN);
-        } catch (java.lang.reflect.InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
@@ -602,7 +603,7 @@ public class LibvirtStorageAdaptorTest {
 
         try {
             method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
-        } catch (java.lang.reflect.InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
@@ -620,7 +621,7 @@ public class LibvirtStorageAdaptorTest {
 
         try {
             method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
-        } catch (java.lang.reflect.InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
@@ -638,8 +639,688 @@ public class LibvirtStorageAdaptorTest {
 
         try {
             method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
-        } catch (java.lang.reflect.InvocationTargetException e) {
+        } catch (InvocationTargetException e) {
             throw e.getCause();
         }
     }
+
+    @Test
+    public void testShouldSecureZeroFill_EnabledInDetails() throws Exception {
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "true");
+
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "shouldSecureZeroFill", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, mockPool);
+
+        assert result : "Should return true when CLVM_SECURE_ZERO_FILL is 'true'";
+    }
+
+    @Test
+    public void testShouldSecureZeroFill_DisabledInDetails() throws Exception {
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "false");
+
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "shouldSecureZeroFill", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, mockPool);
+
+        assert !result : "Should return false when CLVM_SECURE_ZERO_FILL is 'false'";
+    }
+
+    @Test
+    public void testShouldSecureZeroFill_NotSetInDetails() throws Exception {
+        Map<String, String> details = new HashMap<>();
+
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "shouldSecureZeroFill", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, mockPool);
+
+        assert !result : "Should return false when CLVM_SECURE_ZERO_FILL is not set";
+    }
+
+    @Test
+    public void testShouldSecureZeroFill_NullDetails() throws Exception {
+        Mockito.when(mockPool.getDetails()).thenReturn(null);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "shouldSecureZeroFill", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, mockPool);
+
+        assert !result : "Should return false when details are null";
+    }
+
+    @Test
+    public void testExtractVgNameFromPool_SimplePath() throws Exception {
+        String vgName = "testvg";
+        Mockito.when(mockPool.getLocalPath()).thenReturn(vgName);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "extractVgNameFromPool", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        String result = (String) method.invoke(libvirtStorageAdaptor, mockPool);
+
+        assertEquals("Should extract VG name correctly", vgName, result);
+    }
+
+    @Test
+    public void testExtractVgNameFromPool_PathWithSlash() throws Exception {
+        String vgName = "testvg";
+        String path = "/" + vgName;
+        Mockito.when(mockPool.getLocalPath()).thenReturn(path);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "extractVgNameFromPool", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        String result = (String) method.invoke(libvirtStorageAdaptor, mockPool);
+
+        assertEquals("Should extract VG name from path with leading slash", vgName, result);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testExtractVgNameFromPool_NullPath() throws Throwable {
+        Mockito.when(mockPool.getLocalPath()).thenReturn(null);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "extractVgNameFromPool", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        try {
+            method.invoke(libvirtStorageAdaptor, mockPool);
+        } catch (InvocationTargetException e) {
+            throw e.getCause();
+        }
+    }
+
+    @Test
+    public void testLvExists_VolumeExists() throws Exception {
+        String lvPath = "/dev/testvg/test-volume";
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> {
+                when(mock.execute()).thenReturn(null);
+            });
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "lvExists", String.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, lvPath);
+
+        assert result : "Should return true when LV exists (lvs returns null)";
+    }
+
+    @Test
+    public void testLvExists_VolumeDoesNotExist() throws Exception {
+        String lvPath = "/dev/testvg/nonexistent-volume";
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> {
+                when(mock.execute()).thenReturn("Volume not found");
+            });
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "lvExists", String.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, lvPath);
+
+        assert !result : "Should return false when LV does not exist";
+    }
+
+    @Test
+    public void testGetVgName_SimpleName() throws Exception {
+        String vgName = "acsvg";
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "getVgName", String.class);
+        method.setAccessible(true);
+
+        String result = (String) method.invoke(libvirtStorageAdaptor, vgName);
+
+        assertEquals("Should return VG name as-is for simple name", vgName, result);
+    }
+
+    @Test
+    public void testGetVgName_PathWithSlash() throws Exception {
+        String vgName = "acsvg";
+        String path = "/" + vgName;
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "getVgName", String.class);
+        method.setAccessible(true);
+
+        String result = (String) method.invoke(libvirtStorageAdaptor, path);
+
+        assertEquals("Should extract VG name from path with leading slash", vgName, result);
+    }
+
+    @Test
+    public void testGetVgName_DevPath() throws Exception {
+        String vgName = "acsvg";
+        String path = "/dev/" + vgName;
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "getVgName", String.class);
+        method.setAccessible(true);
+
+        String result = (String) method.invoke(libvirtStorageAdaptor, path);
+
+        assertEquals("Should extract VG name from /dev/ path", vgName, result);
+    }
+
+    @Test
+    public void testCreatePhysicalDiskFromClvmLv_CLVM() throws Exception {
+        String lvPath = "/dev/testvg/test-volume";
+        String volumeUuid = "test-volume";
+        long size = 10737418240L;
+
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "createPhysicalDiskFromClvmLv",
+            String.class, String.class, KVMStoragePool.class, long.class);
+        method.setAccessible(true);
+
+        KVMPhysicalDisk result = (KVMPhysicalDisk) method.invoke(
+            libvirtStorageAdaptor, lvPath, volumeUuid, mockPool, size);
+
+        assertNotNull("Physical disk should be created", result);
+        assertEquals("Format should be RAW for CLVM", PhysicalDiskFormat.RAW, result.getFormat());
+        assertEquals("Size should match", size, result.getSize());
+        assertEquals("Path should match", lvPath, result.getPath());
+    }
+
+    @Test
+    public void testCreatePhysicalDiskFromClvmLv_CLVM_NG() throws Exception {
+        String lvPath = "/dev/testvg-ng/test-volume";
+        String volumeUuid = "test-volume";
+        long size = 10737418240L;
+
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "createPhysicalDiskFromClvmLv",
+            String.class, String.class, KVMStoragePool.class, long.class);
+        method.setAccessible(true);
+
+        KVMPhysicalDisk result = (KVMPhysicalDisk) method.invoke(
+            libvirtStorageAdaptor, lvPath, volumeUuid, mockPool, size);
+
+        assertNotNull("Physical disk should be created", result);
+        assertEquals("Format should be QCOW2 for CLVM_NG", PhysicalDiskFormat.QCOW2, result.getFormat());
+        assertEquals("Size should match", size, result.getSize());
+        assertEquals("Path should match", lvPath, result.getPath());
+    }
+
+    @Test
+    public void testCLVMPoolSecureZeroFill_TrueValue() {
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "true");
+
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        String value = mockPool.getDetails().get(KVMStoragePool.CLVM_SECURE_ZERO_FILL);
+        assert "true".equals(value) : "CLVM_SECURE_ZERO_FILL should be 'true'";
+    }
+
+    @Test
+    public void testCLVMPoolSecureZeroFill_FalseValue() {
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "false");
+
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        String value = mockPool.getDetails().get(KVMStoragePool.CLVM_SECURE_ZERO_FILL);
+        assert "false".equals(value) : "CLVM_SECURE_ZERO_FILL should be 'false'";
+    }
+
+    @Test
+    public void testCLVMVolumePathConstruction() {
+        String vgName = "acsvg";
+        String volumeUuid = "550e8400-e29b-41d4-a716-446655440000";
+        String expectedPath = "/dev/" + vgName + "/" + volumeUuid;
+
+        assertEquals("/dev/acsvg/550e8400-e29b-41d4-a716-446655440000", expectedPath);
+    }
+
+    @Test
+    public void testCLVMNGPoolSupportsQCOW2Format() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        Storage.StoragePoolType type = mockPool.getType();
+        PhysicalDiskFormat expectedFormat = PhysicalDiskFormat.QCOW2;
+
+        assert type == Storage.StoragePoolType.CLVM_NG : "Pool type should be CLVM_NG";
+        assertNotNull("QCOW2 format should be available", expectedFormat);
+    }
+
+    @Test
+    public void testCLVMPoolSupportsRAWFormat() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        Storage.StoragePoolType type = mockPool.getType();
+        PhysicalDiskFormat expectedFormat = PhysicalDiskFormat.RAW;
+
+        assert type == Storage.StoragePoolType.CLVM : "Pool type should be CLVM";
+        assertNotNull("RAW format should be available", expectedFormat);
+    }
+
+    @Test
+    public void testVerifyLvExistsInVg_VolumeExists() throws Exception {
+        String volumeUuid = "test-volume-uuid";
+        String vgName = "testvg";
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn(null));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "verifyLvExistsInVg", String.class, String.class);
+        method.setAccessible(true);
+
+        method.invoke(libvirtStorageAdaptor, volumeUuid, vgName);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testVerifyLvExistsInVg_VolumeDoesNotExist() throws Throwable {
+        String volumeUuid = "nonexistent-volume";
+        String vgName = "testvg";
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn("  Volume not found"));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "verifyLvExistsInVg", String.class, String.class);
+        method.setAccessible(true);
+
+        try {
+            method.invoke(libvirtStorageAdaptor, volumeUuid, vgName);
+        } catch (InvocationTargetException e) {
+            throw e.getCause();
+        }
+    }
+
+    @Test
+    public void testGetClvmVolumeSize_MethodExists() throws Exception {
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "getClvmVolumeSize", String.class);
+        method.setAccessible(true);
+
+        assertNotNull("getClvmVolumeSize method should exist", method);
+    }
+
+    @Test
+    public void testCLVMPoolIsBlockBased() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        boolean isBlockBased = mockPool.getType() == Storage.StoragePoolType.CLVM ||
+                               mockPool.getType() == Storage.StoragePoolType.CLVM_NG;
+
+        assert isBlockBased : "CLVM should be recognized as block-based storage";
+    }
+
+    @Test
+    public void testCLVMNGPoolIsBlockBased() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        boolean isBlockBased = mockPool.getType() == Storage.StoragePoolType.CLVM ||
+                               mockPool.getType() == Storage.StoragePoolType.CLVM_NG;
+
+        assert isBlockBased : "CLVM_NG should be recognized as block-based storage";
+    }
+
+    @Test
+    public void testGetVgName_ComplexPath() throws Exception {
+        String vgName = "acsvg-ng";
+        String path = "/dev/mapper/" + vgName;
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "getVgName", String.class);
+        method.setAccessible(true);
+
+        String result = (String) method.invoke(libvirtStorageAdaptor, path);
+
+        assertNotNull("VG name should not be null", result);
+    }
+
+    @Test
+    public void testExtractVgNameFromPool_EmptyPath() throws Exception {
+        Mockito.when(mockPool.getLocalPath()).thenReturn("");
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "extractVgNameFromPool", KVMStoragePool.class);
+        method.setAccessible(true);
+
+        try {
+            method.invoke(libvirtStorageAdaptor, mockPool);
+            assert false : "Should throw CloudRuntimeException for empty path";
+        } catch (InvocationTargetException e) {
+            assert e.getCause() instanceof CloudRuntimeException :
+                "Should throw CloudRuntimeException";
+        }
+    }
+
+    @Test
+    public void testCleanupCLVMVolume_VolumeExists_WithSecureZeroFill() throws Exception {
+        String volumeUuid = UUID.randomUUID().toString();
+        String vgName = "testvg";
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "true");
+
+        Mockito.when(mockPool.getLocalPath()).thenReturn(vgName);
+        Mockito.when(mockPool.getUuid()).thenReturn(UUID.randomUUID().toString());
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn(null));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "cleanupCLVMVolume", String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
+
+        assert result : "Cleanup should succeed";
+    }
+
+    @Test
+    public void testCleanupCLVMVolume_VolumeExists_WithoutSecureZeroFill() throws Exception {
+        String volumeUuid = UUID.randomUUID().toString();
+        String vgName = "testvg";
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "false");
+
+        Mockito.when(mockPool.getLocalPath()).thenReturn(vgName);
+        Mockito.when(mockPool.getUuid()).thenReturn(UUID.randomUUID().toString());
+        Mockito.when(mockPool.getDetails()).thenReturn(details);
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn(null));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "cleanupCLVMVolume", String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
+
+        assert result : "Cleanup should succeed without zero-fill";
+    }
+
+    @Test
+    public void testCleanupCLVMVolume_VolumeNotFound() throws Exception {
+        String volumeUuid = "nonexistent-volume";
+        String vgName = "testvg";
+
+        Mockito.when(mockPool.getLocalPath()).thenReturn(vgName);
+        Mockito.when(mockPool.getUuid()).thenReturn(UUID.randomUUID().toString());
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn("Volume not found"));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "cleanupCLVMVolume", String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
+
+        assert result : "Should return true when volume not found (already deleted)";
+    }
+
+    @Test
+    public void testCleanupCLVMVolume_NullSourceDir() throws Exception {
+        String volumeUuid = UUID.randomUUID().toString();
+
+        Mockito.when(mockPool.getLocalPath()).thenReturn(null);
+        Mockito.when(mockPool.getUuid()).thenReturn(UUID.randomUUID().toString());
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "cleanupCLVMVolume", String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        boolean result = (boolean) method.invoke(libvirtStorageAdaptor, volumeUuid, mockPool);
+
+        assert result : "Should return true when source dir is null";
+    }
+
+    @Test
+    public void testRemoveLvOnFailure_Success() throws Exception {
+        String lvPath = "/dev/testvg/test-volume";
+        int timeout = 30000;
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn(null));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "removeLvOnFailure", String.class, int.class);
+        method.setAccessible(true);
+
+        method.invoke(libvirtStorageAdaptor, lvPath, timeout);
+    }
+
+    @Test
+    public void testEnsureTemplateAccessibility_CLVM_NG_TemplateVolume() throws Exception {
+        String volumeUuid = "template-550e8400-e29b-41d4-a716-446655440000";
+        String lvPath = "/dev/testvg/template-550e8400-e29b-41d4-a716-446655440000";
+
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        mockScriptConstruction = Mockito.mockConstruction(Script.class,
+            (mock, context) -> when(mock.execute()).thenReturn(null));
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "ensureTemplateAccessibility", String.class, String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        method.invoke(libvirtStorageAdaptor, volumeUuid, lvPath, mockPool);
+    }
+
+    @Test
+    public void testEnsureTemplateAccessibility_CLVM_NonTemplate() throws Exception {
+        String volumeUuid = UUID.randomUUID().toString();
+        String lvPath = "/dev/testvg/" + volumeUuid;
+
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "ensureTemplateAccessibility", String.class, String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        method.invoke(libvirtStorageAdaptor, volumeUuid, lvPath, mockPool);
+    }
+
+    @Test
+    public void testCreateVirtualClvmPool_MethodExists() throws Exception {
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "createVirtualClvmPool",
+            String.class, String.class, String.class,
+            Storage.StoragePoolType.class, Map.class);
+        method.setAccessible(true);
+
+        assertNotNull("createVirtualClvmPool method should exist", method);
+    }
+
+    @Test
+    public void testFindDeviceNodeAfterActivation_MethodExists() throws Exception {
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "findDeviceNodeAfterActivation",
+            String.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertNotNull("findDeviceNodeAfterActivation method should exist", method);
+    }
+
+    @Test
+    public void testHandleMissingDeviceNode_MethodExists() throws Exception {
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "handleMissingDeviceNode",
+            String.class, String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        assertNotNull("handleMissingDeviceNode method should exist", method);
+    }
+
+    @Test
+    public void testHandleMissingDeviceNode_NonTemplate_MethodExists() throws Exception {
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "handleMissingDeviceNode",
+            String.class, String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        assertNotNull("handleMissingDeviceNode method should exist", method);
+    }
+
+    @Test
+    public void testFindAccessibleDeviceNode_MethodExists() throws Exception {
+        Method method = LibvirtStorageAdaptor.class.getDeclaredMethod(
+            "findAccessibleDeviceNode",
+            String.class, String.class, KVMStoragePool.class);
+        method.setAccessible(true);
+
+        assertNotNull("findAccessibleDeviceNode method should exist", method);
+    }
+
+    @Test
+    public void testCLVMNGDiskFormat_IsQCOW2() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        PhysicalDiskFormat format = (mockPool.getType() == Storage.StoragePoolType.CLVM_NG)
+            ? PhysicalDiskFormat.QCOW2
+            : PhysicalDiskFormat.RAW;
+
+        assertEquals("CLVM_NG should use QCOW2 format", PhysicalDiskFormat.QCOW2, format);
+    }
+
+    @Test
+    public void testCLVMDiskFormat_IsRAW() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        PhysicalDiskFormat format = (mockPool.getType() == Storage.StoragePoolType.CLVM_NG)
+            ? PhysicalDiskFormat.QCOW2
+            : PhysicalDiskFormat.RAW;
+
+        assertEquals("CLVM should use RAW format", PhysicalDiskFormat.RAW, format);
+    }
+
+    @Test
+    public void testCLVMPoolDetails_DefaultSecureZeroFill() {
+        Map<String, String> details = new HashMap<>();
+
+        String value = details.get(KVMStoragePool.CLVM_SECURE_ZERO_FILL);
+
+        assert value == null : "CLVM_SECURE_ZERO_FILL should default to null";
+    }
+
+    @Test
+    public void testCLVMPoolDetails_CustomSecureZeroFill() {
+        Map<String, String> details = new HashMap<>();
+        details.put(KVMStoragePool.CLVM_SECURE_ZERO_FILL, "true");
+
+        String value = details.get(KVMStoragePool.CLVM_SECURE_ZERO_FILL);
+
+        assertEquals("CLVM_SECURE_ZERO_FILL should be 'true'", "true", value);
+    }
+
+    @Test
+    public void testCLVMVolumeDeviceMapperPathEscaping() {
+        String vgName = "acsvg-ng";
+        String volumeUuid = "ea19580e-0882-4ab8-973b-a320637037f4";
+
+        String vgNameEscaped = vgName.replace("-", "--");
+        String volumeUuidEscaped = volumeUuid.replace("-", "--");
+        String mapperPath = "/dev/mapper/" + vgNameEscaped + "-" + volumeUuidEscaped;
+
+        String expectedPath = "/dev/mapper/acsvg--ng-ea19580e--0882--4ab8--973b--a320637037f4";
+        assertEquals("Mapper path should have escaped hyphens", expectedPath, mapperPath);
+    }
+
+    @Test
+    public void testCLVMTemplateNamePrefix() {
+        String templateUuid = UUID.randomUUID().toString();
+        String templateName = "template-" + templateUuid;
+
+        assert templateName.startsWith("template-");
+        assert templateName.length() > 9;
+    }
+
+    @Test
+    public void testCLVMPoolTypeIsNotFileSystem() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        boolean isFileSystem = mockPool.getType() == Storage.StoragePoolType.Filesystem;
+
+        assert !isFileSystem : "CLVM is not a file system pool type";
+    }
+
+    @Test
+    public void testCLVMNGPoolTypeIsNotFileSystem() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        boolean isFileSystem = mockPool.getType() == Storage.StoragePoolType.Filesystem;
+
+        assert !isFileSystem : "CLVM_NG is not a file system pool type";
+    }
+
+    @Test
+    public void testCLVMPoolTypeIsNotNFS() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM);
+
+        boolean isNFS = mockPool.getType() == Storage.StoragePoolType.NetworkFilesystem;
+
+        assert !isNFS : "CLVM is not an NFS pool type";
+    }
+
+    @Test
+    public void testCLVMNGPoolTypeIsNotRBD() {
+        Mockito.when(mockPool.getType()).thenReturn(Storage.StoragePoolType.CLVM_NG);
+
+        boolean isRBD = mockPool.getType() == Storage.StoragePoolType.RBD;
+
+        assert !isRBD : "CLVM_NG is not an RBD pool type";
+    }
+
+    @Test
+    public void testCLVMVolumeUUIDFormat() {
+        String volumeUuid = UUID.randomUUID().toString();
+
+        assert volumeUuid.matches("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
+    }
+
+    @Test
+    public void testCLVMNGBackingFileFormat() {
+        String vgName = "testvg";
+        String templateUuid = UUID.randomUUID().toString();
+        String backingFile = "/dev/" + vgName + "/template-" + templateUuid;
+
+        assert backingFile.startsWith("/dev/");
+        assert backingFile.contains("template-");
+        assert backingFile.contains(templateUuid);
+    }
+
+    @Test
+    public void testCLVMPoolLocalPathValidation() {
+        String vgName = "acsvg";
+
+        Mockito.when(mockPool.getLocalPath()).thenReturn(vgName);
+
+        String localPath = mockPool.getLocalPath();
+
+        assertNotNull("Local path should not be null", localPath);
+        assert !localPath.isEmpty() : "Local path should not be empty";
+    }
 }