vsock: move testing utilities in separate module

Signed-off-by: Cihodaru Alexandru <[email protected]>

Author: AlexandruCihodaru

src/devices/src/virtio/vsock/csm/connection.rs

@@ -673,11 +673,11 @@ mod tests {
     use utils::eventfd::EventFd;
 
     use super::super::super::defs::uapi;
-    use super::super::super::tests::TestContext;
     use super::super::defs as csm_defs;
     use super::*;
 
     use crate::virtio::vsock::device::RXQ_INDEX;
+    use crate::virtio::vsock::test_utils::TestContext;
 
     const LOCAL_CID: u64 = 2;
     const PEER_CID: u64 = 3;

src/devices/src/virtio/vsock/device.rs

@@ -320,9 +320,9 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::super::tests::TestContext;
     use super::*;
     use crate::virtio::vsock::defs::uapi;
+    use crate::virtio::vsock::test_utils::TestContext;
 
     #[test]
     fn test_virtio_device() {

src/devices/src/virtio/vsock/event_handler.rs

@@ -224,14 +224,14 @@ mod tests {
     use std::sync::atomic::Ordering;
     use std::sync::{Arc, Mutex};
 
-    use super::super::tests::{EventHandlerContext, TestContext};
     use super::super::*;
     use super::*;
 
-    use crate::virtio::device::VirtioDevice;
     use crate::virtio::vsock::packet::VSOCK_PKT_HDR_SIZE;
+    use crate::virtio::vsock::test_utils::{EventHandlerContext, TestContext};
     use crate::virtio::VIRTIO_MMIO_INT_VRING;
     use crate::Error as DeviceError;
+    use vm_memory::Bytes;
 
     #[test]
     fn test_irq() {
@@ -466,7 +466,7 @@ mod tests {
     // desc_idx = 0 we are altering the header (first descriptor in the chain), and when
     // desc_idx = 1 we are altering the packet buffer.
     fn vsock_bof_helper(test_ctx: &mut TestContext, desc_idx: usize, addr: u64, len: u32) {
-        use vm_memory::{Bytes, GuestAddress};
+        use vm_memory::GuestAddress;
 
         assert!(desc_idx <= 1);
 

src/devices/src/virtio/vsock/mod.rs

@@ -10,6 +10,7 @@ mod device;
 mod event_handler;
 mod packet;
 pub mod persist;
+pub mod test_utils;
 mod unix;
 
 use std::os::unix::io::AsRawFd;
@@ -160,182 +161,3 @@ pub trait VsockChannel {
 /// Currently, the only implementation we have is `crate::virtio::unix::muxer::VsockMuxer`, which
 /// translates guest-side vsock connections to host-side Unix domain socket connections.
 pub trait VsockBackend: VsockChannel + VsockEpollListener + Send {}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::device::{Vsock, RXQ_INDEX, TXQ_INDEX};
-    use super::packet::VSOCK_PKT_HDR_SIZE;
-    use super::*;
-
-    use std::os::unix::io::{AsRawFd, RawFd};
-    use utils::eventfd::EventFd;
-
-    use crate::virtio::queue::tests::VirtQueue as GuestQ;
-    use crate::virtio::{VirtioDevice, VIRTQ_DESC_F_NEXT, VIRTQ_DESC_F_WRITE};
-    use utils::epoll::EpollEvent;
-    use vm_memory::{GuestAddress, GuestMemoryMmap};
-
-    pub struct TestBackend {
-        pub evfd: EventFd,
-        pub rx_err: Option<VsockError>,
-        pub tx_err: Option<VsockError>,
-        pub pending_rx: bool,
-        pub rx_ok_cnt: usize,
-        pub tx_ok_cnt: usize,
-        pub evset: Option<EventSet>,
-    }
-
-    impl TestBackend {
-        pub fn new() -> Self {
-            Self {
-                evfd: EventFd::new(libc::EFD_NONBLOCK).unwrap(),
-                rx_err: None,
-                tx_err: None,
-                pending_rx: false,
-                rx_ok_cnt: 0,
-                tx_ok_cnt: 0,
-                evset: None,
-            }
-        }
-        pub fn set_rx_err(&mut self, err: Option<VsockError>) {
-            self.rx_err = err;
-        }
-        pub fn set_tx_err(&mut self, err: Option<VsockError>) {
-            self.tx_err = err;
-        }
-        pub fn set_pending_rx(&mut self, prx: bool) {
-            self.pending_rx = prx;
-        }
-    }
-
-    impl VsockChannel for TestBackend {
-        fn recv_pkt(&mut self, _pkt: &mut VsockPacket) -> Result<()> {
-            let cool_buf = [0xDu8, 0xE, 0xA, 0xD, 0xB, 0xE, 0xE, 0xF];
-            match self.rx_err.take() {
-                None => {
-                    if let Some(buf) = _pkt.buf_mut() {
-                        for i in 0..buf.len() {
-                            buf[i] = cool_buf[i % cool_buf.len()];
-                        }
-                    }
-                    self.rx_ok_cnt += 1;
-                    Ok(())
-                }
-                Some(e) => Err(e),
-            }
-        }
-
-        fn send_pkt(&mut self, _pkt: &VsockPacket) -> Result<()> {
-            match self.tx_err.take() {
-                None => {
-                    self.tx_ok_cnt += 1;
-                    Ok(())
-                }
-                Some(e) => Err(e),
-            }
-        }
-
-        fn has_pending_rx(&self) -> bool {
-            self.pending_rx
-        }
-    }
-
-    impl AsRawFd for TestBackend {
-        fn as_raw_fd(&self) -> RawFd {
-            self.evfd.as_raw_fd()
-        }
-    }
-
-    impl VsockEpollListener for TestBackend {
-        fn get_polled_evset(&self) -> EventSet {
-            EventSet::IN
-        }
-        fn notify(&mut self, evset: EventSet) {
-            self.evset = Some(evset);
-        }
-    }
-    impl VsockBackend for TestBackend {}
-
-    pub struct TestContext {
-        pub cid: u64,
-        pub mem: GuestMemoryMmap,
-        pub mem_size: usize,
-        pub device: Vsock<TestBackend>,
-    }
-
-    impl TestContext {
-        pub fn new() -> Self {
-            const CID: u64 = 52;
-            const MEM_SIZE: usize = 1024 * 1024 * 128;
-            let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), MEM_SIZE)]).unwrap();
-            Self {
-                cid: CID,
-                mem,
-                mem_size: MEM_SIZE,
-                device: Vsock::new(CID, TestBackend::new()).unwrap(),
-            }
-        }
-
-        pub fn create_event_handler_context(&self) -> EventHandlerContext {
-            const QSIZE: u16 = 2;
-
-            let guest_rxvq = GuestQ::new(GuestAddress(0x0010_0000), &self.mem, QSIZE as u16);
-            let guest_txvq = GuestQ::new(GuestAddress(0x0020_0000), &self.mem, QSIZE as u16);
-            let guest_evvq = GuestQ::new(GuestAddress(0x0030_0000), &self.mem, QSIZE as u16);
-            let rxvq = guest_rxvq.create_queue();
-            let txvq = guest_txvq.create_queue();
-            let evvq = guest_evvq.create_queue();
-
-            // Set up one available descriptor in the RX queue.
-            guest_rxvq.dtable[0].set(
-                0x0040_0000,
-                VSOCK_PKT_HDR_SIZE as u32,
-                VIRTQ_DESC_F_WRITE | VIRTQ_DESC_F_NEXT,
-                1,
-            );
-            guest_rxvq.dtable[1].set(0x0040_1000, 4096, VIRTQ_DESC_F_WRITE, 0);
-
-            guest_rxvq.avail.ring[0].set(0);
-            guest_rxvq.avail.idx.set(1);
-
-            // Set up one available descriptor in the TX queue.
-            guest_txvq.dtable[0].set(0x0050_0000, VSOCK_PKT_HDR_SIZE as u32, VIRTQ_DESC_F_NEXT, 1);
-            guest_txvq.dtable[1].set(0x0050_1000, 4096, 0, 0);
-            guest_txvq.avail.ring[0].set(0);
-            guest_txvq.avail.idx.set(1);
-
-            let queues = vec![rxvq, txvq, evvq];
-            EventHandlerContext {
-                guest_rxvq,
-                guest_txvq,
-                guest_evvq,
-                device: Vsock::with_queues(self.cid, TestBackend::new(), queues).unwrap(),
-            }
-        }
-    }
-
-    pub struct EventHandlerContext<'a> {
-        pub device: Vsock<TestBackend>,
-        pub guest_rxvq: GuestQ<'a>,
-        pub guest_txvq: GuestQ<'a>,
-        pub guest_evvq: GuestQ<'a>,
-    }
-
-    impl<'a> EventHandlerContext<'a> {
-        pub fn mock_activate(&mut self, mem: GuestMemoryMmap) {
-            // Artificially activate the device.
-            self.device.activate(mem).unwrap();
-        }
-
-        pub fn signal_txq_event(&mut self) {
-            self.device.queue_events[TXQ_INDEX].write(1).unwrap();
-            self.device
-                .handle_txq_event(&EpollEvent::new(EventSet::IN, 0));
-        }
-        pub fn signal_rxq_event(&mut self) {
-            self.device.queue_events[RXQ_INDEX].write(1).unwrap();
-            self.device
-                .handle_rxq_event(&EpollEvent::new(EventSet::IN, 0));
-        }
-    }
-}

src/devices/src/virtio/vsock/packet.rs

@@ -343,11 +343,11 @@ mod tests {
 
     use vm_memory::{GuestAddress, GuestMemoryMmap};
 
-    use super::super::tests::TestContext;
     use super::*;
-    use crate::virtio::queue::tests::VirtqDesc as GuestQDesc;
+    use crate::virtio::test_utils::VirtqDesc as GuestQDesc;
     use crate::virtio::vsock::defs::MAX_PKT_BUF_SIZE;
     use crate::virtio::vsock::device::{RXQ_INDEX, TXQ_INDEX};
+    use crate::virtio::vsock::test_utils::TestContext;
     use crate::virtio::VIRTQ_DESC_F_WRITE;
 
     macro_rules! create_context {

src/devices/src/virtio/vsock/persist.rs

@@ -122,11 +122,11 @@ where
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use super::super::tests::{TestBackend, TestContext};
     use super::device::AVAIL_FEATURES;
     use super::*;
     use crate::virtio::device::VirtioDevice;
     use crate::virtio::vsock::defs::uapi;
+    use crate::virtio::vsock::test_utils::{TestBackend, TestContext};
     use utils::byte_order;
 
     impl Persist<'_> for TestBackend {