Add unit tests

Unit tests for IO manager.

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

Author: Jing Liu

Diff for: coverage_config.json

@@ -1,5 +1,5 @@
 {
-  "coverage_score": 75.8,
+  "coverage_score": 78.7,
   "exclude_path": "",
   "crate_features": ""
 }

Diff for: src/device_manager.rs

@@ -234,3 +234,125 @@ impl IoManager {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    const PIO_ADDRESS_SIZE: u16 = 4;
+    const PIO_ADDRESS_BASE: u16 = 0x40;
+    const MMIO_ADDRESS_SIZE: u64 = 0x8765_4321;
+    const MMIO_ADDRESS_BASE: u64 = 0x1234_5678;
+    const LEGACY_IRQ: u32 = 4;
+    const CONFIG_DATA: u32 = 0x1234;
+
+    struct DummyDevice {
+        config: Mutex<u32>,
+    }
+
+    impl DummyDevice {
+        fn new(config: u32) -> Self {
+            DummyDevice {
+                config: Mutex::new(config),
+            }
+        }
+    }
+
+    impl DeviceIo for DummyDevice {
+        fn read(&self, _base: IoAddress, _offset: IoAddress, data: &mut [u8]) {
+            if data.len() > 4 {
+                return;
+            }
+            for (idx, iter) in data.iter_mut().enumerate() {
+                let config = self.config.lock().expect("failed to acquire lock");
+                *iter = (*config >> (idx * 8) & 0xff) as u8;
+            }
+        }
+
+        fn write(&self, _base: IoAddress, _offset: IoAddress, data: &[u8]) {
+            let mut config = self.config.lock().expect("failed to acquire lock");
+            *config = u32::from(data[0]) & 0xff;
+        }
+    }
+
+    #[test]
+    fn test_register_unregister_device_io() {
+        let mut io_mgr = IoManager::new();
+        let dummy = DummyDevice::new(0);
+        let dum = Arc::new(dummy);
+
+        let mut resource: Vec<Resource> = Vec::new();
+        let mmio = Resource::MmioAddressRange {
+            base: MMIO_ADDRESS_BASE,
+            size: MMIO_ADDRESS_SIZE,
+        };
+        let irq = Resource::LegacyIrq(LEGACY_IRQ);
+
+        resource.push(mmio);
+        resource.push(irq);
+
+        assert!(io_mgr.register_device_io(dum.clone(), &resource).is_ok());
+        assert!(io_mgr.unregister_device_io(&resource).is_ok())
+    }
+
+    #[test]
+    fn test_mmio_read_write() {
+        let mut io_mgr: IoManager = Default::default();
+        let dum = Arc::new(DummyDevice::new(CONFIG_DATA));
+        let mut resource: Vec<Resource> = Vec::new();
+
+        let mmio = Resource::MmioAddressRange {
+            base: MMIO_ADDRESS_BASE,
+            size: MMIO_ADDRESS_SIZE,
+        };
+        resource.push(mmio);
+        assert!(io_mgr.register_device_io(dum.clone(), &resource).is_ok());
+
+        let mut data = [0; 4];
+        assert!(io_mgr.mmio_read(MMIO_ADDRESS_BASE, &mut data).is_ok());
+        assert_eq!(data, [0x34, 0x12, 0, 0]);
+
+        assert!(io_mgr
+            .mmio_read(MMIO_ADDRESS_BASE + MMIO_ADDRESS_SIZE, &mut data)
+            .is_err());
+
+        data = [0; 4];
+        assert!(io_mgr.mmio_write(MMIO_ADDRESS_BASE, &data).is_ok());
+        assert_eq!(*dum.config.lock().unwrap(), 0);
+
+        assert!(io_mgr
+            .mmio_write(MMIO_ADDRESS_BASE + MMIO_ADDRESS_SIZE, &data)
+            .is_err());
+    }
+
+    #[test]
+    fn test_pio_read_write() {
+        let mut io_mgr: IoManager = Default::default();
+        let dum = Arc::new(DummyDevice::new(CONFIG_DATA));
+        let mut resource: Vec<Resource> = Vec::new();
+
+        let pio = Resource::PioAddressRange {
+            base: PIO_ADDRESS_BASE,
+            size: PIO_ADDRESS_SIZE,
+        };
+        resource.push(pio);
+        assert!(io_mgr.register_device_io(dum.clone(), &resource).is_ok());
+
+        let mut data = [0; 4];
+        assert!(io_mgr.pio_read(PIO_ADDRESS_BASE, &mut data).is_ok());
+        assert_eq!(data, [0x34, 0x12, 0, 0]);
+
+        assert!(io_mgr
+            .pio_read(PIO_ADDRESS_BASE + PIO_ADDRESS_SIZE, &mut data)
+            .is_err());
+
+        data = [0; 4];
+        assert!(io_mgr.pio_write(PIO_ADDRESS_BASE, &data).is_ok());
+        assert_eq!(*dum.config.lock().unwrap(), 0);
+
+        assert!(io_mgr
+            .pio_write(PIO_ADDRESS_BASE + PIO_ADDRESS_SIZE, &data)
+            .is_err());
+    }
+}