Add mutant testing

This adds tests/mutants.rs which was created by githup copilot assistance.

Note:
This file is partially is generated with github copilot assistance.
The *only* objective here is to generate coverage over all code paths to
make 'cargo mutants' pass. Then the main test suite should pass
'cargo +nightly miri test'. Unless otherwise noted the tests here are
not extensively reviewed for semantic correctness. Eventually human
reviewed tests here should be moved to other unit tests.

Hard to test side effects and functions that are trivially correct and
are marked with #[mutants::skip].

Author: cehteh

Cargo.toml

@@ -22,3 +22,6 @@ xmacro = "0.2.0"
 # include debug info for flamgraph and other profiling tools
 [profile.bench]
 debug = true
+
+[dependencies]
+mutants = "0.0.3"

src/drain.rs

@@ -39,6 +39,7 @@ pub struct Drain<'a, H, T> {
 }
 
 impl<H: fmt::Debug, T: fmt::Debug> fmt::Debug for Drain<'_, H, T> {
+    #[mutants::skip]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct(&format!(
             "Drain<{}, {}>",

src/lib.rs

@@ -138,11 +138,13 @@ impl<H, T> HeaderVec<H, T> {
     /// HeaderVec`, this is the method is always exact and can be slightly faster than the non
     /// mutable `len()`.
     #[cfg(feature = "atomic_append")]
+    #[mutants::skip]
     #[inline(always)]
     pub fn len_exact(&mut self) -> usize {
         *self.header_mut().len.get_mut()
     }
     #[cfg(not(feature = "atomic_append"))]
+    #[mutants::skip]
     #[inline(always)]
     pub fn len_exact(&mut self) -> usize {
         self.header_mut().len
@@ -152,11 +154,13 @@ impl<H, T> HeaderVec<H, T> {
     /// produce racy results in case another thread atomically appended to
     /// `&self`. Nevertheless it is always safe to use.
     #[cfg(feature = "atomic_append")]
+    #[mutants::skip]
     #[inline(always)]
     pub fn len(&self) -> usize {
         self.len_atomic_relaxed()
     }
     #[cfg(not(feature = "atomic_append"))]
+    #[mutants::skip]
     #[inline(always)]
     pub fn len(&self) -> usize {
         self.header().len
@@ -168,11 +172,13 @@ impl<H, T> HeaderVec<H, T> {
     /// atomically appends data to this `HeaderVec` while we still work with the result of
     /// this method.
     #[cfg(not(feature = "atomic_append"))]
+    #[mutants::skip]
     #[inline(always)]
     pub fn len_strict(&self) -> usize {
         self.header().len
     }
     #[cfg(feature = "atomic_append")]
+    #[mutants::skip]
     #[inline(always)]
     pub fn len_strict(&self) -> usize {
         self.len_atomic_acquire()
@@ -283,6 +289,7 @@ impl<H, T> HeaderVec<H, T> {
     }
 
     /// Reserves capacity for exactly `additional` more elements to be inserted in the given `HeaderVec`.
+    #[mutants::skip]
     #[inline]
     pub fn reserve_exact(&mut self, additional: usize) {
         self.reserve_intern(additional, true, &mut None);
@@ -291,6 +298,7 @@ impl<H, T> HeaderVec<H, T> {
     /// Reserves capacity for exactly `additional` more elements to be inserted in the given `HeaderVec`.
     /// This method must be used when `HeaderVecWeak` are used. It takes a closure that is responsible for
     /// updating the weak references as additional parameter.
+    #[mutants::skip]
     #[inline]
     pub fn reserve_exact_with_weakfix(&mut self, additional: usize, weak_fixup: WeakFixupFn) {
         self.reserve_intern(additional, true, &mut Some(weak_fixup));
@@ -329,6 +337,7 @@ impl<H, T> HeaderVec<H, T> {
     }
 
     /// Resizes the vector hold exactly `self.len()` elements.
+    #[mutants::skip]
     #[inline(always)]
     pub fn shrink_to_fit(&mut self) {
         self.shrink_to(0);
@@ -337,6 +346,7 @@ impl<H, T> HeaderVec<H, T> {
     /// Resizes the vector hold exactly `self.len()` elements.
     /// This method must be used when `HeaderVecWeak` are used. It takes a closure that is responsible for
     /// updating the weak references as additional parameter.
+    #[mutants::skip]
     #[inline(always)]
     pub fn shrink_to_fit_with_weakfix(&mut self, weak_fixup: WeakFixupFn) {
         self.shrink_to_with_weakfix(0, weak_fixup);
@@ -564,6 +574,7 @@ impl<H, T> HeaderVec<H, T> {
     ///
     /// [`clear`]: HeaderVec::clear
     /// [`drain`]: HeaderVec::drain
+    #[mutants::skip]
     pub fn truncate(&mut self, len: usize) {
         unsafe {
             let old_len = self.len_exact();
@@ -609,6 +620,7 @@ impl<H, T> HeaderVec<H, T> {
     }
 
     /// Gives the offset in units of T (as if the pointer started at an array of T) that the slice actually starts at.
+    #[mutants::skip]
     #[inline(always)]
     const fn offset() -> usize {
         // The first location, in units of size_of::<T>(), that is after the header
@@ -1054,6 +1066,7 @@ where
     H: Debug,
     T: Debug,
 {
+    #[mutants::skip]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("HeaderVec")
             .field("header", &self.header().head)

src/splice.rs

@@ -55,6 +55,7 @@ where
     I: Iterator + fmt::Debug,
     I::Item: fmt::Debug,
 {
+    #[mutants::skip]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct(&format!(
             "Splice<{}, {}>",
@@ -70,6 +71,7 @@ where
 
 impl<H, I: Iterator> Drop for Splice<'_, H, I> {
     #[track_caller]
+    #[mutants::skip]
     fn drop(&mut self) {
         self.drain.by_ref().for_each(drop);
         // At this point draining is done and the only remaining tasks are splicing