rm test util duplication

Author: rustopian

sysvar/src/clock.rs

@@ -173,30 +173,6 @@ mod tests {
         assert_eq!(got, expected);
     }
 
-    struct ValidateIdSyscall {
-        data: Vec<u8>,
-    }
-
-    impl crate::program_stubs::SyscallStubs for ValidateIdSyscall {
-        fn sol_get_sysvar(
-            &self,
-            sysvar_id_addr: *const u8,
-            var_addr: *mut u8,
-            offset: u64,
-            length: u64,
-        ) -> u64 {
-            // Validate that the macro passed the correct sysvar id pointer
-            let passed_id = unsafe { *(sysvar_id_addr as *const solana_pubkey::Pubkey) };
-            assert_eq!(passed_id, id());
-
-            let slice = unsafe { std::slice::from_raw_parts_mut(var_addr, length as usize) };
-            slice.copy_from_slice(
-                &self.data[offset as usize..(offset.saturating_add(length)) as usize],
-            );
-            solana_program_entrypoint::SUCCESS
-        }
-    }
-
     #[test]
     #[serial]
     fn test_clock_get_passes_correct_sysvar_id() {
@@ -208,7 +184,7 @@ mod tests {
             unix_timestamp: 55,
         };
         let data = to_bytes(&expected);
-        let prev = crate::program_stubs::set_syscall_stubs(Box::new(ValidateIdSyscall { data }));
+        let prev = crate::tests::mock_get_sysvar_syscall_with_id(&data, &id());
 
         let got = Clock::get().unwrap();
         assert_eq!(got, expected);

sysvar/src/epoch_rewards.rs

@@ -218,11 +218,6 @@ mod tests {
     #[serial]
     #[cfg(feature = "bincode")]
     fn test_epoch_rewards_get() {
-        use {
-            crate::program_stubs::{set_syscall_stubs, SyscallStubs},
-            solana_program_entrypoint::SUCCESS,
-        };
-
         let expected = EpochRewards {
             distribution_starting_block_height: 42,
             num_partitions: 7,
@@ -236,26 +231,7 @@ mod tests {
         let data = bincode::serialize(&expected).unwrap();
         assert_eq!(data.len(), 81);
 
-        struct MockSyscall {
-            data: Vec<u8>,
-        }
-        impl SyscallStubs for MockSyscall {
-            fn sol_get_sysvar(
-                &self,
-                _sysvar_id_addr: *const u8,
-                var_addr: *mut u8,
-                offset: u64,
-                length: u64,
-            ) -> u64 {
-                unsafe {
-                    let slice = core::slice::from_raw_parts_mut(var_addr, length as usize);
-                    slice.copy_from_slice(&self.data[offset as usize..(offset + length) as usize]);
-                }
-                SUCCESS
-            }
-        }
-
-        set_syscall_stubs(Box::new(MockSyscall { data }));
+        crate::tests::mock_get_sysvar_syscall(&data);
         let got = EpochRewards::get().unwrap();
         assert_eq!(got, expected);
     }

sysvar/src/epoch_schedule.rs

@@ -177,35 +177,11 @@ mod tests {
     #[serial]
     #[cfg(feature = "bincode")]
     fn test_epoch_schedule_get() {
-        use {
-            crate::program_stubs::{set_syscall_stubs, SyscallStubs},
-            solana_program_entrypoint::SUCCESS,
-        };
-
         let expected = EpochSchedule::custom(1234, 5678, false);
         let data = bincode::serialize(&expected).unwrap();
         assert_eq!(data.len(), 33);
 
-        struct MockSyscall {
-            data: Vec<u8>,
-        }
-        impl SyscallStubs for MockSyscall {
-            fn sol_get_sysvar(
-                &self,
-                _sysvar_id_addr: *const u8,
-                var_addr: *mut u8,
-                offset: u64,
-                length: u64,
-            ) -> u64 {
-                unsafe {
-                    let slice = core::slice::from_raw_parts_mut(var_addr, length as usize);
-                    slice.copy_from_slice(&self.data[offset as usize..(offset + length) as usize]);
-                }
-                SUCCESS
-            }
-        }
-
-        set_syscall_stubs(Box::new(MockSyscall { data }));
+        crate::tests::mock_get_sysvar_syscall(&data);
         let got = EpochSchedule::get().unwrap();
         assert_eq!(got, expected);
     }

sysvar/src/lib.rs

@@ -328,10 +328,13 @@ mod tests {
     impl Sysvar for TestSysvar {}
     impl SysvarSerialize for TestSysvar {}
 
-    // NOTE tests that use this mock MUST carry the #[serial] attribute
+    // NOTE: Tests using these mocks MUST carry the #[serial] attribute
+    // because they modify global SYSCALL_STUBS state.
+
     struct MockGetSysvarSyscall {
         data: Vec<u8>,
     }
+
     impl SyscallStubs for MockGetSysvarSyscall {
         #[allow(clippy::arithmetic_side_effects)]
         fn sol_get_sysvar(
@@ -346,12 +349,49 @@ mod tests {
             SUCCESS
         }
     }
+
+    /// Mock syscall stub for tests. Requires `#[serial]` attribute.
     pub fn mock_get_sysvar_syscall(data: &[u8]) {
         set_syscall_stubs(Box::new(MockGetSysvarSyscall {
             data: data.to_vec(),
         }));
     }
 
+    struct ValidateIdSyscall {
+        data: Vec<u8>,
+        expected_id: Pubkey,
+    }
+
+    impl SyscallStubs for ValidateIdSyscall {
+        #[allow(clippy::arithmetic_side_effects)]
+        fn sol_get_sysvar(
+            &self,
+            sysvar_id_addr: *const u8,
+            var_addr: *mut u8,
+            offset: u64,
+            length: u64,
+        ) -> u64 {
+            // Validate that the correct sysvar id pointer was passed
+            let passed_id = unsafe { *(sysvar_id_addr as *const Pubkey) };
+            assert_eq!(passed_id, self.expected_id);
+
+            let slice = unsafe { std::slice::from_raw_parts_mut(var_addr, length as usize) };
+            slice.copy_from_slice(&self.data[offset as usize..(offset + length) as usize]);
+            SUCCESS
+        }
+    }
+
+    /// Mock syscall stub that validates sysvar ID. Requires `#[serial]` attribute.
+    pub fn mock_get_sysvar_syscall_with_id(
+        data: &[u8],
+        expected_id: &Pubkey,
+    ) -> Box<dyn SyscallStubs> {
+        set_syscall_stubs(Box::new(ValidateIdSyscall {
+            data: data.to_vec(),
+            expected_id: *expected_id,
+        }))
+    }
+
     /// Convert a value to its in-memory byte representation.
     ///
     /// # Safety

sysvar/src/rent.rs

@@ -173,11 +173,6 @@ mod tests {
     #[serial]
     #[cfg(feature = "bincode")]
     fn test_rent_get() {
-        use {
-            crate::program_stubs::{set_syscall_stubs, SyscallStubs},
-            solana_program_entrypoint::SUCCESS,
-        };
-
         let expected = Rent {
             lamports_per_byte_year: 123,
             exemption_threshold: 2.5,
@@ -187,26 +182,7 @@ mod tests {
         let data = bincode::serialize(&expected).unwrap();
         assert_eq!(data.len(), 17);
 
-        struct MockSyscall {
-            data: Vec<u8>,
-        }
-        impl SyscallStubs for MockSyscall {
-            fn sol_get_sysvar(
-                &self,
-                _sysvar_id_addr: *const u8,
-                var_addr: *mut u8,
-                offset: u64,
-                length: u64,
-            ) -> u64 {
-                unsafe {
-                    let slice = core::slice::from_raw_parts_mut(var_addr, length as usize);
-                    slice.copy_from_slice(&self.data[offset as usize..(offset + length) as usize]);
-                }
-                SUCCESS
-            }
-        }
-
-        set_syscall_stubs(Box::new(MockSyscall { data }));
+        crate::tests::mock_get_sysvar_syscall(&data);
         let got = Rent::get().unwrap();
         assert_eq!(got, expected);
     }