unit tests added

Author: vagrant

Cargo.toml

@@ -31,8 +31,8 @@ libc = { version = "0.2.58", optional = true }
 xenctrl = { git = "https://github.com/Wenzel/xenctrl", optional = true }
 xenstore = { git = "https://github.com/Wenzel/xenstore", optional = true }
 xenforeignmemory = { git = "https://github.com/Wenzel/xenforeignmemory", optional = true }
-kvmi = { version = "0.2.1", optional = true }
 fdp = { git = "https://github.com/Wenzel/fdp", optional = true }
+kvmi = { version = "0.2.1", optional = true }
 winapi = { version = "0.3.8", features = ["tlhelp32", "winnt", "handleapi", "securitybaseapi"], optional = true }
 widestring = { version = "0.4.0", optional = true }
 ntapi = { version = "0.3.3", optional = true }

src/driver/kvm.rs

@@ -377,7 +377,7 @@ impl<T: KVMIntrospectable> Drop for Kvm<T> {
     }
 }
 
-#[cfg(test)]
+/*#[cfg(test)]
 mod tests {
     use super::*;
     use kvmi::{kvm_regs, kvm_sregs, KvmMsrs};
@@ -386,31 +386,62 @@ mod tests {
     use std::fmt::{Debug, Formatter};
     use test_case::test_case;
 
-    #[test]
-    fn test_fail_to_create_kvm_driver_if_kvmi_init_returns_error() {
-        let mut kvmi_mock = MockKVMi::default();
-        kvmi_mock.expect_init().returning(|_| {
-            Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "something went wrong",
-            ))
-        });
 
-        let result = Kvm::new(
-            "some_vm",
-            kvmi_mock,
-            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
-        );
 
-        assert!(result.is_err(), "Expected error, got ok instead!");
-    }
+
+
 
     #[test_case(1; "single vcpu")]
     #[test_case(2; "two vcpus")]
     #[test_case(16; "sixteen vcpus")]
-    fn test_create_kvm_driver_if_guest_domain_is_valid(vcpu_count: u32) {
-        let mut kvmi_mock = MockKVMi::default();
-        kvmi_mock.expect_init().returning(|_| Ok(()));
+
+
+    #[test_case(1; "single vcpu")]
+    #[test_case(2; "two vcpus")]
+    #[test_case(16; "sixteen vcpus")]
+
+
+    mock! {
+        KVMi{}
+        trait Debug {
+            fn fmt<'a>(&self, f: &mut Formatter<'a>) -> std::fmt::Result;
+        }
+        trait KVMIntrospectable: Debug {
+            fn init(&mut self, socket_path: &str) -> Result<(), std::io::Error>;
+            fn control_events(
+                &self,
+                vcpu: u16,
+                intercept_type: KVMiInterceptType,
+                enabled: bool,
+            ) -> Result<(), std::io::Error>;
+            fn control_cr(&self, vcpu: u16, reg: KVMiCr, enabled: bool) -> Result<(), std::io::Error>;
+            fn control_msr(&self, vcpu: u16, reg: u32, enabled: bool) -> Result<(), std::io::Error>;
+            fn read_physical(&self, gpa: u64, buffer: &mut [u8]) -> Result<(), std::io::Error>;
+            fn write_physical(&self, gpa: u64, buffer: &[u8]) -> Result<(), std::io::Error>;
+            fn get_page_access(&self, gpa: u64) -> Result<KVMiPageAccess, std::io::Error>;
+            fn set_page_access(&self, gpa: u64, access: KVMiPageAccess) -> Result<(), std::io::Error>;
+            fn pause(&self) -> Result<(), std::io::Error>;
+            fn get_vcpu_count(&self) -> Result<u32, std::io::Error>;
+            fn get_registers(&self, vcpu: u16) -> Result<(kvm_regs, kvm_sregs, KvmMsrs), std::io::Error>;
+            fn set_registers(&self, vcpu: u16, regs: &kvm_regs) -> Result<(), std::io::Error>;
+            fn wait_and_pop_event(&self, ms: i32) -> Result<Option<KVMiEvent>, std::io::Error>;
+            fn reply(&self, event: &KVMiEvent, reply_type: KVMiEventReply) -> Result<(), std::io::Error>;
+            fn get_maximum_gfn(&self) -> Result<u64, std::io::Error>;
+        }
+    }
+}*/
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use kvmi::{kvm_regs, kvm_sregs, KvmMsrs};
+    use mockall::mock;
+    use mockall::predicate::{eq, function};
+    use std::fmt::{Debug, Formatter};
+    use test_case::test_case;
+
+    fn setup_mock(kvmi_mock: &mut MockKVMi, vcpu_count: u32) {
+        kvmi_mock.expect_init().times(1).returning(|_| Ok(()));
         kvmi_mock
             .expect_get_vcpu_count()
             .returning(move || Ok(vcpu_count));
@@ -488,7 +519,33 @@ mod tests {
                 .times(1)
                 .returning(|_, _, _| Ok(()));
         }
+    }
+
+    #[test]
+    fn test_fail_to_create_kvm_driver_if_kvmi_init_returns_error() {
+        let mut kvmi_mock = MockKVMi::default();
+        kvmi_mock.expect_init().returning(|_| {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "something went wrong",
+            ))
+        });
+
+        let result = Kvm::new(
+            "some_vm",
+            kvmi_mock,
+            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
+        );
+
+        assert!(result.is_err(), "Expected error, got ok instead!");
+    }
 
+    #[test_case(1; "single vcpu")]
+    #[test_case(2; "two vcpus")]
+    #[test_case(16; "sixteen vcpus")]
+    fn test_create_kvm_driver_if_guest_domain_is_valid(vcpu_count: u32) {
+        let mut kvmi_mock = MockKVMi::default();
+        setup_mock(&mut kvmi_mock, vcpu_count);
         let result = Kvm::new(
             "some_vm",
             kvmi_mock,
@@ -498,6 +555,130 @@ mod tests {
         assert!(result.is_ok(), "Expected ok, got error instead!");
     }
 
+    #[test_case(1; "single vcpu")]
+    fn test_pause_vcpu(vcpu_count: u32) {
+        let mut kvmi_mock = MockKVMi::default();
+        setup_mock(&mut kvmi_mock, vcpu_count);
+        kvmi_mock.expect_pause().times(1).returning(|| Ok(()));
+        let mut kvm = Kvm::new(
+            "some_vm",
+            kvmi_mock,
+            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
+        )
+        .expect("Failed to create driver");
+        let result = Kvm::pause(&mut kvm);
+        assert!(result.is_ok(), "Expected ok, got error instead!");
+    }
+
+    #[test_case(1; "single vcpu")]
+    fn test_resume_vcpu(vcpu_count: u32) {
+        let mut kvmi_mock = MockKVMi::default();
+        setup_mock(&mut kvmi_mock, vcpu_count);
+        kvmi_mock
+            .expect_wait_and_pop_event()
+            .times(5)
+            .returning(|_| {
+                Ok(Some(KVMiEvent {
+                    vcpu: 0,
+                    ev_type: KVMiEventType::PauseVCPU,
+                    ffi_event: std::ptr::null_mut(),
+                }))
+            });
+        kvmi_mock.expect_reply().times(5).returning(|_, _| Ok(()));
+        let mut kvm = Kvm::new(
+            "some_vm",
+            kvmi_mock,
+            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
+        )
+        .expect("Failed to create driver");
+        kvm.expect_pause_ev = 5;
+        let result = Kvm::resume(&mut kvm);
+        assert!(result.is_ok(), "Expected ok, got error instead!");
+    }
+
+    #[test_case(1; "single vcpu")]
+    fn test_read_and_write_physical(vcpu_count: u32) {
+        let mut kvmi_mock = MockKVMi::default();
+        setup_mock(&mut kvmi_mock, vcpu_count);
+        kvmi_mock
+            .expect_read_physical()
+            .times(1)
+            .returning(|_, _| Ok(()));
+        kvmi_mock
+            .expect_write_physical()
+            .times(1)
+            .returning(|_, _| Ok(()));
+        let mut kvm = Kvm::new(
+            "some_vm",
+            kvmi_mock,
+            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
+        )
+        .expect("Failed to create driver");
+        let mut paddr: u64 = 0;
+        let mut buffer: [u8; 4096] = [0; 4096];
+        let result_read = Kvm::read_physical(&mut kvm, paddr, &mut buffer);
+        paddr = 0;
+        buffer = [0; 4096];
+        let result_write = Kvm::write_physical(&mut kvm, paddr, &mut buffer);
+        assert!(result_read.is_ok(), "Expected ok, got error instead!");
+        assert!(result_write.is_ok(), "Expected ok, got error instead!");
+    }
+
+    #[test_case(1; "single vcpu")]
+    fn test_toggle_intercept(vcpu_count: u32) {
+        let mut kvmi_mock = MockKVMi::default();
+        kvmi_mock
+            .expect_control_cr()
+            .with(eq(0), function(|x| matches!(x, KVMiCr::Cr3)), eq(true))
+            .times(1)
+            .returning(|_, _, _| Ok(()));
+        kvmi_mock
+            .expect_control_msr()
+            .times(0)
+            .returning(|_, _, _| Ok(()));
+        kvmi_mock
+            .expect_control_events()
+            .with(
+                eq(1),
+                function(|x| matches!(x, KVMiInterceptType::Breakpoint)),
+                eq(true),
+            )
+            .times(1)
+            .returning(|_, _, _| Ok(()));
+        kvmi_mock
+            .expect_control_events()
+            .with(
+                eq(1),
+                function(|x| matches!(x, KVMiInterceptType::Pagefault)),
+                eq(true),
+            )
+            .times(1)
+            .returning(|_, _, _| Ok(()));
+
+        setup_mock(&mut kvmi_mock, vcpu_count);
+        let mut kvm = Kvm::new(
+            "some_vm",
+            kvmi_mock,
+            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
+        )
+        .expect("Failed to create driver");
+        let mut vcpu: u16 = 0;
+        let mut intercept_type = InterceptType::Cr(CrType::Cr3);
+        let mut enabled: bool = true;
+        let result_cr = Kvm::toggle_intercept(&mut kvm, vcpu, intercept_type, enabled);
+        vcpu = 1;
+        intercept_type = InterceptType::Breakpoint;
+        enabled = true;
+        let result_breakpoint = Kvm::toggle_intercept(&mut kvm, vcpu, intercept_type, enabled);
+        vcpu = 1;
+        intercept_type = InterceptType::Pagefault;
+        enabled = true;
+        let result_pagefault = Kvm::toggle_intercept(&mut kvm, vcpu, intercept_type, enabled);
+        assert!(result_cr.is_ok(), "Expected ok, got error instead!");
+        assert!(result_breakpoint.is_ok(), "Expected ok, got error instead!");
+        assert!(result_pagefault.is_ok(), "Expected ok, got error instead!");
+    }
+
     mock! {
         KVMi{}
         trait Debug {