Merge #316 #317

316: speed up cargo miri test r=japaric a=japaric

by making some "exhaustive" tests less exhaustive

317: impl {Clone, PartialEq} for HistoryBuffer {...} r=japaric a=finnbear

- `impl Clone for HistoryBuffer`
- `impl PartialEq for HistoryBuffer`

Both are tested fairly rigorously.

Motivation is to use this type in a `yew::Properties` struct, which requires both traits to be implemented.

Co-authored-by: Jorge Aparicio <jorge.aparicio@ferrous-systems.com>
Co-authored-by: Finn Bear <finnbearlabs@gmail.com>

Author: 3 people

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+- Add `Clone` and `PartialEq` implementations to `HistoryBuffer`.
+
 ### Changed
 
 - [breaking-change] `IndexMap` and `IndexSet` now require that keys implement the `core::hash::Hash`

src/histbuf.rs

@@ -238,6 +238,21 @@ where
     }
 }
 
+impl<T, const N: usize> Clone for HistoryBuffer<T, N>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        let mut ret = Self::new();
+        for (new, old) in ret.data.iter_mut().zip(self.as_slice()) {
+            new.write(old.clone());
+        }
+        ret.filled = self.filled;
+        ret.write_at = self.write_at;
+        ret
+    }
+}
+
 impl<T, const N: usize> Drop for HistoryBuffer<T, N> {
     fn drop(&mut self) {
         unsafe {
@@ -279,6 +294,15 @@ impl<T, const N: usize> Default for HistoryBuffer<T, N> {
     }
 }
 
+impl<T, const N: usize> PartialEq for HistoryBuffer<T, N>
+where
+    T: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.oldest_ordered().eq(other.oldest_ordered())
+    }
+}
+
 /// An iterator on the underlying buffer ordered from oldest data to newest
 #[derive(Clone)]
 pub struct OldestOrdered<'a, T, const N: usize> {
@@ -311,6 +335,7 @@ impl<'a, T, const N: usize> Iterator for OldestOrdered<'a, T, N> {
 mod tests {
     use crate::HistoryBuffer;
     use core::fmt::Debug;
+    use core::sync::atomic::{AtomicUsize, Ordering};
 
     #[test]
     fn new() {
@@ -350,6 +375,47 @@ mod tests {
         assert_eq!(x.as_slice(), [1; 4]);
     }
 
+    #[test]
+    fn clone() {
+        let mut x: HistoryBuffer<u8, 3> = HistoryBuffer::new();
+        for i in 0..10 {
+            assert_eq!(x.as_slice(), x.clone().as_slice());
+            x.write(i);
+        }
+
+        // Records number of clones locally and globally.
+        static GLOBAL: AtomicUsize = AtomicUsize::new(0);
+        #[derive(Default, PartialEq, Debug)]
+        struct InstrumentedClone(usize);
+
+        impl Clone for InstrumentedClone {
+            fn clone(&self) -> Self {
+                GLOBAL.fetch_add(1, Ordering::Relaxed);
+                Self(self.0 + 1)
+            }
+        }
+
+        let mut y: HistoryBuffer<InstrumentedClone, 2> = HistoryBuffer::new();
+        let _ = y.clone();
+        assert_eq!(GLOBAL.load(Ordering::Relaxed), 0);
+        y.write(InstrumentedClone(0));
+        assert_eq!(GLOBAL.load(Ordering::Relaxed), 0);
+        assert_eq!(y.clone().as_slice(), [InstrumentedClone(1)]);
+        assert_eq!(GLOBAL.load(Ordering::Relaxed), 1);
+        y.write(InstrumentedClone(0));
+        assert_eq!(GLOBAL.load(Ordering::Relaxed), 1);
+        assert_eq!(
+            y.clone().as_slice(),
+            [InstrumentedClone(1), InstrumentedClone(1)]
+        );
+        assert_eq!(GLOBAL.load(Ordering::Relaxed), 3);
+        assert_eq!(
+            y.clone().clone().clone().as_slice(),
+            [InstrumentedClone(3), InstrumentedClone(3)]
+        );
+        assert_eq!(GLOBAL.load(Ordering::Relaxed), 9);
+    }
+
     #[test]
     fn recent() {
         let mut x: HistoryBuffer<u8, 4> = HistoryBuffer::new();
@@ -430,4 +496,30 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn partial_eq() {
+        let mut x: HistoryBuffer<u8, 3> = HistoryBuffer::new();
+        let mut y: HistoryBuffer<u8, 3> = HistoryBuffer::new();
+        assert_eq!(x, y);
+        x.write(1);
+        assert_ne!(x, y);
+        y.write(1);
+        assert_eq!(x, y);
+        for _ in 0..4 {
+            x.write(2);
+            assert_ne!(x, y);
+            for i in 0..5 {
+                x.write(i);
+                y.write(i);
+            }
+            assert_eq!(
+                x,
+                y,
+                "{:?} {:?}",
+                x.iter().collect::<Vec<_>>(),
+                y.iter().collect::<Vec<_>>()
+            );
+        }
+    }
 }

src/indexmap.rs

@@ -1208,7 +1208,12 @@ mod tests {
         assert_eq!(a.get("k1"), a.get("k2"));
     }
 
+    // tests that use this constant take too long to run under miri, specially on CI, with a map of
+    // this size so make the map smaller when using miri
+    #[cfg(not(miri))]
     const MAP_SLOTS: usize = 4096;
+    #[cfg(miri)]
+    const MAP_SLOTS: usize = 64;
     fn almost_filled_map() -> FnvIndexMap<usize, usize, MAP_SLOTS> {
         let mut almost_filled = FnvIndexMap::new();
         for i in 1..MAP_SLOTS {