From 3ee66c5bb882893cc75d92643ad315da51a19c03 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 16:37:31 +0000
Subject: [PATCH 1/3] Modify push test

Cargo mutants found mutants in witness.

Add to the existing test `push` to kill the mutants from `is_empty` and
`third_to_last`.

Change the dummy values to make the progression of `elements` down the
test easier to follow.
---
 primitives/src/witness.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index abec3e1fb2..d0c9553936 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -497,6 +497,7 @@ mod test {
     fn push() {
         // Sanity check default.
         let mut witness = Witness::default();
+        assert!(witness.is_empty());
         assert_eq!(witness.last(), None);
         assert_eq!(witness.second_to_last(), None);
 
@@ -506,10 +507,11 @@ mod test {
         assert_eq!(witness.nth(3), None);
 
         // Push a single byte element onto the witness stack.
-        let push = [0_u8];
+        let push = [11_u8];
         witness.push(push);
+        assert!(!witness.is_empty());
 
-        let elements = [1u8, 0];
+        let elements = [1u8, 11];
         let expected = Witness {
             witness_elements: 1,
             content: append_u32_vec(&elements, &[0]), // Start at index 0.
@@ -529,10 +531,10 @@ mod test {
         assert_eq!(witness.nth(3), None);
 
         // Now push 2 byte element onto the witness stack.
-        let push = [2u8, 3u8];
+        let push = [21u8, 22u8];
         witness.push(push);
 
-        let elements = [1u8, 0, 2, 2, 3];
+        let elements = [1u8, 11, 2, 21, 22];
         let expected = Witness {
             witness_elements: 2,
             content: append_u32_vec(&elements, &[0, 2]),
@@ -552,10 +554,10 @@ mod test {
         assert_eq!(witness.last(), Some(element_1));
 
         // Now push another 2 byte element onto the witness stack.
-        let push = [4u8, 5u8];
+        let push = [31u8, 32u8];
         witness.push(push);
 
-        let elements = [1u8, 0, 2, 2, 3, 2, 4, 5];
+        let elements = [1u8, 11, 2, 21, 22, 2, 31, 32];
         let expected = Witness {
             witness_elements: 3,
             content: append_u32_vec(&elements, &[0, 2, 5]),
@@ -571,6 +573,7 @@ mod test {
         assert_eq!(witness.nth(2), Some(element_2));
         assert_eq!(witness.nth(3), None);
 
+        assert_eq!(witness.third_to_last(), Some(element_0));
         assert_eq!(witness.second_to_last(), Some(element_1));
         assert_eq!(witness.last(), Some(element_2));
     }

From 2f95064cfd0ce07d002f6e0d027e99f6dcef5d22 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 17:08:30 +0000
Subject: [PATCH 2/3] Add from_parts test

Add a test to kill the mutant in `from_parts__unstable`
---
 primitives/src/witness.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index d0c9553936..af8e0c0acf 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -597,6 +597,18 @@ mod test {
         }
     }
 
+    #[test]
+    fn witness_from_parts() {
+        let elements = [1u8, 11, 2, 21, 22];
+        let witness_elements = 2;
+        let content = append_u32_vec(&elements, &[0, 2]);
+        let indices_start = elements.len();
+        let witness = Witness::from_parts__unstable(content.clone(), witness_elements, indices_start);
+        assert_eq!(witness.nth(0).unwrap(), [11_u8]);
+        assert_eq!(witness.nth(1).unwrap(), [21_u8, 22]);
+        assert_eq!(witness.size(), 6);
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     fn serde_bincode_backward_compatibility() {

From 7e66091e1e8b6cdd3e40d001ea1824125f7175e7 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 17:31:24 +0000
Subject: [PATCH 3/3] Add from impl tests

Add tests for the witness from implementations to kill all the mutants
found by cargo mutants.
---
 primitives/src/witness.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index af8e0c0acf..d48755992d 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -609,6 +609,33 @@ mod test {
         assert_eq!(witness.size(), 6);
     }
 
+    #[test]
+    fn witness_from_impl() {
+        // Test From implementations with the same 2 elements
+        let vec = vec![vec![11], vec![21, 22]];
+        let slice_vec: &[Vec<u8>] = &vec;
+        let slice_slice: &[&[u8]] = &[&[11u8], &[21, 22]];
+        let vec_slice: Vec<&[u8]> = vec![&[11u8], &[21, 22]];
+
+        let witness_vec_vec = Witness::from(vec.clone());
+        let witness_slice_vec = Witness::from(slice_vec);
+        let witness_slice_slice = Witness::from(slice_slice);
+        let witness_vec_slice = Witness::from(vec_slice);
+
+        let mut expected = Witness::from_slice(&vec);
+        assert_eq!(expected.len(), 2);
+        assert_eq!(expected.to_vec(), vec);
+
+        assert_eq!(witness_vec_vec, expected);
+        assert_eq!(witness_slice_vec, expected);
+        assert_eq!(witness_slice_slice, expected);
+        assert_eq!(witness_vec_slice, expected);
+
+        // Test clear method
+        expected.clear();
+        assert!(expected.is_empty());
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     fn serde_bincode_backward_compatibility() {