Add unit tests for vhost-user device

Adds unit tests for VhostUserDevice
and VhostUserRng

Signed-off-by: Dorinda Bassey <dbassey@redhat.com>

Author: Dorinda Bassey

src/devices/src/virtio/vhost_user/device.rs

@@ -424,3 +424,109 @@ impl VirtioDevice for VhostUserDevice {
         true
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::{self, ErrorKind, Result as IoResult};
+
+    use vhost::vhost_user::VhostUserProtocolFeatures;
+    use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryMmap, GuestMemoryRegion};
+
+    use crate::virtio::Queue as VirtQueue;
+
+    const VHOST_USER_F_PROTOCOL_FEATURES: u64 = 1 << 30;
+
+    fn test_gpa_to_vmm_va(mem: &GuestMemoryMmap, gpa: u64) -> IoResult<u64> {
+        for region in mem.iter() {
+            let region_start = region.start_addr().raw_value();
+            let region_end = region_start + region.len();
+
+            if gpa >= region_start && gpa < region_end {
+                let offset = gpa - region_start;
+                let vmm_va = region.as_ptr() as u64 + offset;
+                return Ok(vmm_va);
+            }
+        }
+
+        Err(io::Error::new(
+            ErrorKind::InvalidInput,
+            format!("GPA 0x{:x} not found in any memory region", gpa),
+        ))
+    }
+
+    #[test]
+    fn test_feature_separation() {
+        let backend_features = 0x1234_5678 | VHOST_USER_F_PROTOCOL_FEATURES;
+        let virtio_features = backend_features & !VHOST_USER_F_PROTOCOL_FEATURES;
+        let backend_only = backend_features & VHOST_USER_F_PROTOCOL_FEATURES;
+
+        assert_eq!(virtio_features, 0x1234_5678);
+        assert_eq!(backend_only, VHOST_USER_F_PROTOCOL_FEATURES);
+        assert_eq!(virtio_features & (1 << 30), 0);
+        assert_eq!(backend_only & (1 << 30), 1 << 30);
+    }
+
+    #[test]
+    fn test_gpa_to_vmm_va_translation() {
+        let regions = vec![
+            (GuestAddress(0x0), 0x1000),
+            (GuestAddress(0x10000), 0x2000),
+            (GuestAddress(0x100000), 0x10000),
+        ];
+        let mem = GuestMemoryMmap::from_ranges(&regions).unwrap();
+
+        // Test valid translations and offset arithmetic
+        let va_0 = test_gpa_to_vmm_va(&mem, 0x0).unwrap();
+        let va_100 = test_gpa_to_vmm_va(&mem, 0x100).unwrap();
+        assert_eq!(va_100, va_0 + 0x100);
+
+        // Test boundaries
+        assert!(test_gpa_to_vmm_va(&mem, 0xfff).is_ok());
+        assert!(test_gpa_to_vmm_va(&mem, 0x1000).is_err());
+        assert!(test_gpa_to_vmm_va(&mem, 0x10000).is_ok());
+        assert!(test_gpa_to_vmm_va(&mem, 0x11fff).is_ok());
+        assert!(test_gpa_to_vmm_va(&mem, 0x12000).is_err());
+
+        // Test gaps and invalid addresses
+        assert!(test_gpa_to_vmm_va(&mem, 0x5000).is_err());
+        assert!(test_gpa_to_vmm_va(&mem, 0x200000).is_err());
+    }
+
+    #[test]
+    fn test_queue_configuration() {
+        let queue_sizes = vec![64, 128, 256, 512];
+        let queues: Vec<VirtQueue> = queue_sizes
+            .iter()
+            .map(|&size| VirtQueue::new(size))
+            .collect();
+
+        assert_eq!(queues.len(), 4);
+        assert_eq!(queues[0].get_max_size(), 64);
+        assert_eq!(queues[3].get_max_size(), 512);
+    }
+
+    #[test]
+    fn test_protocol_feature_flags() {
+        let mut features = VhostUserProtocolFeatures::empty();
+        features |= VhostUserProtocolFeatures::CONFIG;
+        features |= VhostUserProtocolFeatures::MQ;
+
+        assert!(features.contains(VhostUserProtocolFeatures::CONFIG));
+        assert!(features.contains(VhostUserProtocolFeatures::MQ));
+    }
+
+    #[test]
+    fn test_feature_negotiation() {
+        let guest_acked: u64 = 0x1234;
+
+        // Without protocol features
+        let backend_no_proto: u64 = 0x1234_5678;
+        let bits = guest_acked | (backend_no_proto & VHOST_USER_F_PROTOCOL_FEATURES);
+        assert_eq!(bits, guest_acked);
+
+        // With protocol features
+        let backend_with_proto = 0x1234_5678 | VHOST_USER_F_PROTOCOL_FEATURES;
+        let bits = guest_acked | (backend_with_proto & VHOST_USER_F_PROTOCOL_FEATURES);
+        assert_eq!(bits, guest_acked | VHOST_USER_F_PROTOCOL_FEATURES);
+    }
+}

src/devices/src/virtio/vhost_user/rng.rs

@@ -95,3 +95,22 @@ impl VirtioDevice for VhostUserRng {
         self.inner.reset()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{VhostUserRng, NUM_QUEUES, QUEUE_SIZES, RNG_DEV_ID, VIRTIO_ID_RNG};
+
+    #[test]
+    fn test_rng_constants() {
+        assert_eq!(RNG_DEV_ID, "vhost_user_rng");
+        assert_eq!(NUM_QUEUES, 1);
+        assert_eq!(QUEUE_SIZES[0], 256);
+        assert_eq!(VIRTIO_ID_RNG, 4);
+    }
+
+    #[test]
+    fn test_rng_new_fails_without_backend() {
+        let result = VhostUserRng::new("/tmp/nonexistent-socket");
+        assert!(result.is_err());
+    }
+}