add tests for QueueStateSync

For tests that do not use iter(), we can simply replace direct access to the
QueueState with lock() in order to retrieve the guard.

Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

crates/virtio-queue/src/lib.rs

@@ -1193,7 +1193,7 @@ mod tests {
     use vm_memory::{GuestAddress, GuestMemoryMmap};
 
     #[test]
-    pub fn test_offset() {
+    fn test_offset() {
         assert_eq!(offset_of!(Descriptor, addr), 0);
         assert_eq!(offset_of!(Descriptor, len), 8);
         assert_eq!(offset_of!(Descriptor, flags), 12);
@@ -1340,64 +1340,66 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_queue_and_iterator() {
+    fn do_test_queue_and_iterator<QS: QueueStateT>() {
         let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
         let vq = MockSplitQueue::new(m, 16);
 
-        let mut q: Queue<_, QueueState> = vq.as_queue(m);
+        let mut q: Queue<_, QS> = vq.as_queue(m);
 
         // q is currently valid
         assert!(q.is_valid());
 
         // shouldn't be valid when not marked as ready
-        q.state.ready = false;
+        q.lock().ready = false;
         assert!(!q.is_valid());
-        q.state.ready = true;
+        q.lock().ready = true;
+
+        let max_size = q.lock().max_size;
 
         // or when size > max_size
-        q.state.size = q.state.max_size << 1;
+        q.lock().size = max_size << 1;
         assert!(!q.is_valid());
-        q.state.size = q.state.max_size;
+        q.lock().size = max_size;
 
         // or when size is 0
-        q.state.size = 0;
+        q.lock().size = 0;
         assert!(!q.is_valid());
-        q.state.size = q.state.max_size;
+        q.lock().size = max_size;
 
         // or when size is not a power of 2
-        q.state.size = 11;
+        q.lock().size = 11;
         assert!(!q.is_valid());
-        q.state.size = q.state.max_size;
+        q.lock().size = max_size;
 
         // or if the various addresses are off
 
-        q.state.desc_table = GuestAddress(0xffff_ffff);
+        q.lock().desc_table = GuestAddress(0xffff_ffff);
         assert!(!q.is_valid());
-        q.state.desc_table = GuestAddress(0x1001);
+        q.lock().desc_table = GuestAddress(0x1001);
         assert!(!q.is_valid());
-        q.state.desc_table = vq.desc_table_addr();
+        q.lock().desc_table = vq.desc_table_addr();
 
-        q.state.avail_ring = GuestAddress(0xffff_ffff);
+        q.lock().avail_ring = GuestAddress(0xffff_ffff);
         assert!(!q.is_valid());
-        q.state.avail_ring = GuestAddress(0x1001);
+        q.lock().avail_ring = GuestAddress(0x1001);
         assert!(!q.is_valid());
-        q.state.avail_ring = vq.avail_addr();
+        q.lock().avail_ring = vq.avail_addr();
 
-        q.state.used_ring = GuestAddress(0xffff_ffff);
+        q.lock().used_ring = GuestAddress(0xffff_ffff);
         assert!(!q.is_valid());
-        q.state.used_ring = GuestAddress(0x1001);
+        q.lock().used_ring = GuestAddress(0x1001);
         assert!(!q.is_valid());
-        q.state.used_ring = vq.used_addr();
+        q.lock().used_ring = vq.used_addr();
 
         {
+            let mut qstate = q.lock();
             // an invalid queue should return an iterator with no next
-            q.state.ready = false;
-            let mut i = q.iter().unwrap();
+            qstate.ready = false;
+            let mut i = qstate.iter().unwrap();
             assert!(i.next().is_none());
         }
 
-        q.state.ready = true;
+        q.lock().ready = true;
 
         // now let's create two simple descriptor chains
         // the chains are (0, 1) and (2, 3, 4)
@@ -1416,7 +1418,8 @@ mod tests {
             vq.avail().ring().ref_at(1).store(2);
             vq.avail().idx().store(2);
 
-            let mut i = q.iter().unwrap();
+            let mut qstate = q.lock();
+            let mut i = qstate.iter().unwrap();
 
             {
                 let mut c = i.next().unwrap();
@@ -1443,7 +1446,7 @@ mod tests {
             {
                 assert!(i.next().is_none());
                 i.go_to_previous_position();
-                let mut c = q.iter().unwrap().next().unwrap();
+                let mut c = qstate.iter().unwrap().next().unwrap();
                 c.next().unwrap();
                 c.next().unwrap();
                 c.next().unwrap();
@@ -1453,11 +1456,16 @@ mod tests {
     }
 
     #[test]
-    fn test_descriptor_and_iterator() {
+    fn test_queue_and_iterator() {
+        do_test_queue_and_iterator::<QueueState>();
+        do_test_queue_and_iterator::<QueueStateSync>();
+    }
+
+    fn do_test_descriptor_and_iterator<QS: QueueStateT>() {
         let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
         let vq = MockSplitQueue::new(m, 16);
 
-        let mut q: Queue<_, QueueState> = vq.as_queue(m);
+        let mut q: Queue<_, QS> = vq.as_queue(m);
 
         // q is currently valid
         assert!(q.is_valid());
@@ -1479,7 +1487,8 @@ mod tests {
         vq.avail().ring().ref_at(2).store(5);
         vq.avail().idx().store(3);
 
-        let mut i = q.iter().unwrap();
+        let mut qstate = q.lock();
+        let mut i = qstate.iter().unwrap();
 
         {
             let c = i.next().unwrap();
@@ -1515,11 +1524,16 @@ mod tests {
     }
 
     #[test]
-    fn test_add_used() {
+    fn test_descriptor_and_iterator() {
+        do_test_descriptor_and_iterator::<QueueState>();
+        do_test_descriptor_and_iterator::<QueueStateSync>();
+    }
+
+    fn do_test_add_used<QS: QueueStateT>() {
         let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
         let vq = MockSplitQueue::new(m, 16);
 
-        let mut q: Queue<_, QueueState> = vq.as_queue(m);
+        let mut q: Queue<_, QS> = vq.as_queue(m);
 
         assert_eq!(vq.used().idx().load(), 0);
 
@@ -1529,7 +1543,7 @@ mod tests {
 
         // should be ok
         q.add_used(1, 0x1000).unwrap();
-        assert_eq!(q.state.next_used, Wrapping(1));
+        assert_eq!(q.lock().next_used, Wrapping(1));
         assert_eq!(vq.used().idx().load(), 1);
 
         let x = vq.used().ring().ref_at(0).load();
@@ -1538,44 +1552,59 @@ mod tests {
     }
 
     #[test]
-    fn test_reset_queue() {
+    fn test_add_used() {
+        do_test_add_used::<QueueState>();
+        do_test_add_used::<QueueStateSync>();
+    }
+
+    fn do_test_reset_queue<QS: QueueStateT>() {
         let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
         let vq = MockSplitQueue::new(m, 16);
 
-        let mut q: Queue<_, QueueState> = vq.as_queue(m);
-        q.state.size = 8;
-        q.state.ready = true;
-        q.state.reset();
-        assert_eq!(q.state.size, 16);
-        assert_eq!(q.state.ready, false);
+        let mut q: Queue<_, QS> = vq.as_queue(m);
+        let mut qstate = q.lock();
+        qstate.size = 8;
+        qstate.ready = true;
+        qstate.reset();
+        assert_eq!(qstate.size, 16);
+        assert_eq!(qstate.ready, false);
     }
 
     #[test]
-    fn test_needs_notification() {
+    fn test_reset_queue() {
+        do_test_reset_queue::<QueueState>();
+        do_test_reset_queue::<QueueStateSync>();
+    }
+
+    fn do_test_needs_notification<QS: QueueStateT>() {
         let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
         let qsize = 16;
         let vq = MockSplitQueue::new(m, qsize);
 
-        let mut q: Queue<_, QueueState> = vq.as_queue(m);
+        let mut q: Queue<_, QS> = vq.as_queue(m);
+
         let avail_addr = vq.avail_addr();
 
         // It should always return true when EVENT_IDX isn't enabled.
         for i in 0..qsize {
-            q.state.next_used = Wrapping(i);
+            q.lock().next_used = Wrapping(i);
             assert_eq!(q.needs_notification().unwrap(), true);
         }
 
         m.write_obj::<u16>(4, avail_addr.unchecked_add(4 + qsize as u64 * 2))
             .unwrap();
-        q.state.set_event_idx(true);
+        q.lock().set_event_idx(true);
 
         // Incrementing up to this value causes an `u16` to wrap back to 0.
         let wrap = u32::from(u16::MAX) + 1;
 
         for i in 0..wrap + 12 {
-            q.state.next_used = Wrapping(i as u16);
+            let mut qstate = q.lock();
+            qstate.next_used = Wrapping(i as u16);
             // Let's test wrapping around the maximum index value as well.
-            let expected = i == 5 || i == (5 + wrap) || q.state.signalled_used.is_none();
+            let expected = i == 5 || i == (5 + wrap) || qstate.signalled_used.is_none();
+            drop(qstate);
+
             assert_eq!(q.needs_notification().unwrap(), expected);
         }
 
@@ -1589,22 +1618,27 @@ mod tests {
             .unwrap();
 
         assert_eq!(q.needs_notification().unwrap(), false);
-        q.state.next_used = Wrapping(15);
+        q.lock().next_used = Wrapping(15);
         assert_eq!(q.needs_notification().unwrap(), false);
-        q.state.next_used = Wrapping(0);
+        q.lock().next_used = Wrapping(0);
         assert_eq!(q.needs_notification().unwrap(), true);
         assert_eq!(q.needs_notification().unwrap(), false);
     }
 
     #[test]
-    fn test_enable_disable_notification() {
+    fn test_needs_notification() {
+        do_test_needs_notification::<QueueState>();
+        do_test_needs_notification::<QueueStateSync>();
+    }
+
+    fn do_test_enable_disable_notification<QS: QueueStateT>() {
         let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
         let vq = MockSplitQueue::new(m, 16);
 
-        let mut q: Queue<_, QueueState> = vq.as_queue(m);
+        let mut q: Queue<_, QS> = vq.as_queue(m);
         let used_addr = vq.used_addr();
 
-        assert_eq!(q.state.event_idx_enabled, false);
+        assert_eq!(q.lock().event_idx_enabled, false);
 
         q.enable_notification().unwrap();
         let v = m.read_obj::<u16>(used_addr).unwrap();
@@ -1623,13 +1657,19 @@ mod tests {
         m.write_obj::<u16>(2, avail_addr.unchecked_add(2)).unwrap();
 
         assert_eq!(q.enable_notification().unwrap(), true);
-        q.state.next_avail = Wrapping(2);
+        q.lock().next_avail = Wrapping(2);
         assert_eq!(q.enable_notification().unwrap(), false);
 
         m.write_obj::<u16>(8, avail_addr.unchecked_add(2)).unwrap();
 
         assert_eq!(q.enable_notification().unwrap(), true);
-        q.state.next_avail = Wrapping(8);
+        q.lock().next_avail = Wrapping(8);
         assert_eq!(q.enable_notification().unwrap(), false);
     }
+
+    #[test]
+    fn test_enable_disable_notification() {
+        do_test_enable_disable_notification::<QueueState>();
+        do_test_enable_disable_notification::<QueueStateSync>();
+    }
 }