unit tests added

Author: vagrant

src/driver/kvm.rs

@@ -386,31 +386,8 @@ 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(()));
+    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,16 +465,166 @@ 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,
+            Some(DriverInitParam::KVMiSocket("/tmp/introspector".to_string())),
+        );
+
+        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 {