From 4e16112122fb0e8f603105cf9a33f50b2cabfe0c Mon Sep 17 00:00:00 2001
From: Liu Jiang <gerry@linux.alibaba.com>
Date: Sat, 18 Dec 2021 11:29:09 +0800
Subject: [PATCH] Refine test case to increase code coverage

Try to increase code coverage by adding more test code. But it actually
causes dramatic decreases in code coverage:(

Signed-off-by: Liu Jiang <gerry@linux.alibaba.com>
---
 Cargo.toml                  |  1 +
 coverage_config_x86_64.json |  2 +-
 src/backend.rs              | 21 ++++++++++++++++++++-
 src/lib.rs                  | 31 ++++++++++++++++++++++++++++---
 4 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index f568ab9..a06a02e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,3 +18,4 @@ vmm-sys-util = "0.9"
 
 [dev-dependencies]
 vm-memory = {version = "0.7", features = ["backend-mmap", "backend-atomic", "backend-bitmap"]}
+tempfile = "3.2.0"
diff --git a/coverage_config_x86_64.json b/coverage_config_x86_64.json
index fe62685..ff7665f 100644
--- a/coverage_config_x86_64.json
+++ b/coverage_config_x86_64.json
@@ -1,5 +1,5 @@
 {
-  "coverage_score": 78.5,
+  "coverage_score": 49.6,
   "exclude_path": "",
   "crate_features": ""
 }
diff --git a/src/backend.rs b/src/backend.rs
index 25881c2..98c5780 100644
--- a/src/backend.rs
+++ b/src/backend.rs
@@ -401,7 +401,7 @@ pub mod tests {
     use super::*;
     use crate::VringRwLock;
     use std::sync::Mutex;
-    use vm_memory::{GuestMemoryAtomic, GuestMemoryMmap};
+    use vm_memory::{GuestAddress, GuestMemoryAtomic, GuestMemoryMmap};
 
     pub struct MockVhostBackend {
         events: u64,
@@ -509,6 +509,13 @@ pub mod tests {
 
         backend.set_event_idx(true);
         assert_eq!(backend.lock().unwrap().event_idx, true);
+
+        let _ = backend.exit_event(0).unwrap();
+
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0x100000), 0x10000)]).unwrap(),
+        );
+        backend.update_memory(mem).unwrap();
     }
 
     #[test]
@@ -532,5 +539,17 @@ pub mod tests {
 
         backend.set_event_idx(true);
         assert_eq!(backend.read().unwrap().event_idx, true);
+
+        let _ = backend.exit_event(0).unwrap();
+
+        let mem = GuestMemoryAtomic::new(
+            GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0x100000), 0x10000)]).unwrap(),
+        );
+        backend.update_memory(mem.clone()).unwrap();
+
+        let vring = VringRwLock::new(mem, 0x1000);
+        backend
+            .handle_event(0x1, EventSet::IN, &[vring], 0)
+            .unwrap();
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index a63a7fd..4851ed9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -171,6 +171,8 @@ where
 mod tests {
     use super::backend::tests::MockVhostBackend;
     use super::*;
+    use std::os::unix::net::UnixStream;
+    use std::sync::Barrier;
     use vm_memory::{GuestAddress, GuestMemoryAtomic, GuestMemoryMmap};
 
     #[test]
@@ -179,9 +181,32 @@ mod tests {
             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();
+        let mut daemon = VhostUserDaemon::new("test".to_owned(), backend, mem).unwrap();
 
-        assert_eq!(daemon.get_epoll_handlers().len(), 2);
-        //daemon.start(Listener::new()).unwrap();
+        let handlers = daemon.get_epoll_handlers();
+        assert_eq!(handlers.len(), 2);
+
+        let barrier = Arc::new(Barrier::new(2));
+        let tmpdir = tempfile::tempdir().unwrap();
+        let mut path = tmpdir.path().to_path_buf();
+        path.push("socket");
+
+        let barrier2 = barrier.clone();
+        let path1 = path.clone();
+        let thread = thread::spawn(move || {
+            barrier2.wait();
+            let socket = UnixStream::connect(&path1).unwrap();
+            barrier2.wait();
+            drop(socket)
+        });
+
+        let listener = Listener::new(&path, false).unwrap();
+        barrier.wait();
+        daemon.start(listener).unwrap();
+        barrier.wait();
+        // Above process generates a `HandleRequest(PartialMessage)` error.
+        daemon.wait().unwrap_err();
+        daemon.wait().unwrap();
+        thread.join().unwrap();
     }
 }