Add more unit test cases

Add more unit test cases to improve code coverage.

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

Cargo.toml

@@ -16,3 +16,6 @@ virtio-bindings = "0.1"
 virtio-queue = { git = "https://github.com/rust-vmm/vm-virtio" }
 vm-memory = {version = "0.6", features = ["backend-mmap", "backend-atomic"]}
 vmm-sys-util = "0.8"
+
+[dev-dependencies]
+vm-memory = {version = "0.6", features = ["backend-mmap", "backend-atomic", "backend-bitmap"]}

src/backend.rs

@@ -377,21 +377,21 @@ impl<T: VhostUserBackendMut<B>, B: Bitmap + 'static> VhostUserBackend<B> for RwL
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::*;
     use epoll::Events;
     use std::io::Error;
     use std::sync::Mutex;
     use vm_memory::{GuestMemoryAtomic, GuestMemoryMmap};
 
-    struct MockVhostBackend {
+    pub struct MockVhostBackend {
         events: u64,
         event_idx: bool,
         acked_features: u64,
     }
 
     impl MockVhostBackend {
-        fn new() -> Self {
+        pub fn new() -> Self {
             MockVhostBackend {
                 events: 0,
                 event_idx: false,

src/event_loop.rs

@@ -220,3 +220,41 @@ impl<S: VhostUserBackend<B>, B: Bitmap + 'static> VringEpollHandler<S, B> {
             .map_err(VringEpollError::HandleEventBackendHandling)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::super::backend::tests::MockVhostBackend;
+    use super::*;
+    use std::sync::{Arc, Mutex};
+    use vm_memory::{GuestAddress, GuestMemoryAtomic, GuestMemoryMmap};
+    use vmm_sys_util::eventfd::EventFd;
+
+    #[test]
+    fn test_vring_epoll_handler() {
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0x100000), 0x10000)]).unwrap(),
+        );
+        let vring = Vring::new(mem, 0x1000);
+        let backend = Arc::new(Mutex::new(MockVhostBackend::new()));
+
+        let handler = VringEpollHandler::new(backend, vec![vring], 0x1).unwrap();
+        assert!(handler.exit_event_id.is_some());
+
+        let eventfd = EventFd::new(0).unwrap();
+        handler
+            .register_listener(eventfd.as_raw_fd(), epoll::Events::EPOLLIN, 1)
+            .unwrap();
+        // Register an already registered fd.
+        handler
+            .register_listener(eventfd.as_raw_fd(), epoll::Events::EPOLLIN, 1)
+            .unwrap_err();
+
+        handler
+            .unregister_listener(eventfd.as_raw_fd(), epoll::Events::EPOLLIN, 1)
+            .unwrap();
+        // unregister an already unregistered fd.
+        handler
+            .unregister_listener(eventfd.as_raw_fd(), epoll::Events::EPOLLIN, 1)
+            .unwrap_err();
+    }
+}

src/lib.rs

@@ -150,3 +150,22 @@ impl<S: VhostUserBackend<B> + Clone, B: NewBitmap + Clone + Send + Sync> VhostUs
         self.handler.lock().unwrap().get_epoll_handlers()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::backend::tests::MockVhostBackend;
+    use super::*;
+    use vm_memory::{GuestAddress, GuestMemoryAtomic, GuestMemoryMmap};
+
+    #[test]
+    fn test_new_daemon() {
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0x100000), 0x10000)]).unwrap(),
+        );
+        let backend = Arc::new(Mutex::new(MockVhostBackend::new()));
+        let daemon = VhostUserDaemon::new("test".to_owned(), backend, mem).unwrap();
+
+        assert_eq!(daemon.get_epoll_handlers().len(), 2);
+        //daemon.start(Listener::new()).unwrap();
+    }
+}

src/vring.rs

@@ -158,3 +158,96 @@ impl<M: GuestAddressSpace> Vring<M> {
         self.get_mut().err = file.map(|f| unsafe { EventFd::from_raw_fd(f.into_raw_fd()) });
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::os::unix::io::AsRawFd;
+    use vm_memory::bitmap::AtomicBitmap;
+    use vmm_sys_util::eventfd::EventFd;
+
+    #[test]
+    fn test_new_vring() {
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<AtomicBitmap>::from_ranges(&[(GuestAddress(0x100000), 0x10000)])
+                .unwrap(),
+        );
+        let vring = Vring::new(mem, 0x1000);
+
+        assert!(vring.get_ref().get_kick().is_none());
+        assert_eq!(vring.get_ref().enabled, false);
+        assert_eq!(vring.get_mut().get_queue_mut().ready, false);
+        assert_eq!(vring.get_mut().get_queue_mut().event_idx_enabled, false);
+
+        vring.set_enabled(true);
+        assert_eq!(vring.get_ref().enabled, true);
+
+        vring.set_queue_info(0x100100, 0x100200, 0x100300);
+        assert_eq!(
+            vring.get_mut().get_queue_mut().desc_table,
+            GuestAddress(0x100100)
+        );
+        assert_eq!(
+            vring.get_mut().get_queue_mut().avail_ring,
+            GuestAddress(0x100200)
+        );
+        assert_eq!(
+            vring.get_mut().get_queue_mut().used_ring,
+            GuestAddress(0x100300)
+        );
+
+        assert_eq!(vring.queue_next_avail(), 0);
+        vring.set_queue_next_avail(0x20);
+        assert_eq!(vring.queue_next_avail(), 0x20);
+
+        vring.set_queue_size(0x200);
+        assert_eq!(vring.get_mut().get_queue_mut().size, 0x200);
+
+        vring.set_queue_event_idx(true);
+        assert_eq!(vring.get_mut().get_queue_mut().event_idx_enabled, true);
+
+        vring.set_queue_ready(true);
+        assert_eq!(vring.get_mut().get_queue_mut().ready, true);
+    }
+
+    #[test]
+    fn test_vring_set_fd() {
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0x100000), 0x10000)]).unwrap(),
+        );
+        let vring = Vring::new(mem, 0x1000);
+
+        vring.set_enabled(true);
+        assert_eq!(vring.get_ref().enabled, true);
+
+        let eventfd = EventFd::new(0).unwrap();
+        let file = unsafe { File::from_raw_fd(eventfd.as_raw_fd()) };
+        assert!(vring.get_ref().kick.is_none());
+        assert_eq!(vring.read_kick().unwrap(), true);
+        vring.set_kick(Some(file));
+        eventfd.write(1).unwrap();
+        assert_eq!(vring.read_kick().unwrap(), true);
+        assert!(vring.get_ref().kick.is_some());
+        vring.set_kick(None);
+        assert!(vring.get_ref().kick.is_none());
+        std::mem::forget(eventfd);
+
+        let eventfd = EventFd::new(0).unwrap();
+        let file = unsafe { File::from_raw_fd(eventfd.as_raw_fd()) };
+        assert!(vring.get_ref().call.is_none());
+        vring.set_call(Some(file));
+        assert!(vring.get_ref().call.is_some());
+        vring.set_call(None);
+        assert!(vring.get_ref().call.is_none());
+        std::mem::forget(eventfd);
+
+        let eventfd = EventFd::new(0).unwrap();
+        let file = unsafe { File::from_raw_fd(eventfd.as_raw_fd()) };
+        assert!(vring.get_ref().err.is_none());
+        vring.set_err(Some(file));
+        assert!(vring.get_ref().err.is_some());
+        vring.set_err(None);
+        assert!(vring.get_ref().err.is_none());
+        std::mem::forget(eventfd);
+    }
+}