Refactors the common code of test and bench targets into the solana_runtime::bpf_test_utils module. (#13203)

programs/bpf_loader/src/lib.rs

@@ -313,102 +313,14 @@ mod tests {
     use super::*;
     use rand::Rng;
     use solana_runtime::{
+        bpf_test_utils::MockInvokeContext,
         feature_set::FeatureSet,
         message_processor::{Executors, ThisInvokeContext},
-        process_instruction::{ComputeBudget, Logger, ProcessInstruction},
-    };
-    use solana_sdk::{
-        account::Account, instruction::CompiledInstruction, instruction::Instruction,
-        message::Message, rent::Rent,
+        process_instruction::ComputeBudget,
     };
+    use solana_sdk::{account::Account, rent::Rent};
     use std::{cell::RefCell, fs::File, io::Read, ops::Range, rc::Rc};
 
-    #[derive(Debug, Default, Clone)]
-    pub struct MockComputeMeter {
-        pub remaining: u64,
-    }
-    impl ComputeMeter for MockComputeMeter {
-        fn consume(&mut self, amount: u64) -> Result<(), InstructionError> {
-            let exceeded = self.remaining < amount;
-            self.remaining = self.remaining.saturating_sub(amount);
-            if exceeded {
-                return Err(InstructionError::ComputationalBudgetExceeded);
-            }
-            Ok(())
-        }
-        fn get_remaining(&self) -> u64 {
-            self.remaining
-        }
-    }
-    #[derive(Debug, Default, Clone)]
-    pub struct MockLogger {
-        pub log: Rc<RefCell<Vec<String>>>,
-    }
-    impl Logger for MockLogger {
-        fn log_enabled(&self) -> bool {
-            true
-        }
-        fn log(&mut self, message: &str) {
-            self.log.borrow_mut().push(message.to_string());
-        }
-    }
-    #[derive(Debug)]
-    pub struct MockInvokeContext {
-        pub key: Pubkey,
-        pub logger: MockLogger,
-        pub compute_budget: ComputeBudget,
-        pub compute_meter: MockComputeMeter,
-    }
-    impl Default for MockInvokeContext {
-        fn default() -> Self {
-            MockInvokeContext {
-                key: Pubkey::default(),
-                logger: MockLogger::default(),
-                compute_budget: ComputeBudget::default(),
-                compute_meter: MockComputeMeter {
-                    remaining: std::u64::MAX,
-                },
-            }
-        }
-    }
-    impl InvokeContext for MockInvokeContext {
-        fn push(&mut self, _key: &Pubkey) -> Result<(), InstructionError> {
-            Ok(())
-        }
-        fn pop(&mut self) {}
-        fn verify_and_update(
-            &mut self,
-            _message: &Message,
-            _instruction: &CompiledInstruction,
-            _accounts: &[Rc<RefCell<Account>>],
-        ) -> Result<(), InstructionError> {
-            Ok(())
-        }
-        fn get_caller(&self) -> Result<&Pubkey, InstructionError> {
-            Ok(&self.key)
-        }
-        fn get_programs(&self) -> &[(Pubkey, ProcessInstruction)] {
-            &[]
-        }
-        fn get_logger(&self) -> Rc<RefCell<dyn Logger>> {
-            Rc::new(RefCell::new(self.logger.clone()))
-        }
-        fn get_compute_budget(&self) -> &ComputeBudget {
-            &self.compute_budget
-        }
-        fn get_compute_meter(&self) -> Rc<RefCell<dyn ComputeMeter>> {
-            Rc::new(RefCell::new(self.compute_meter.clone()))
-        }
-        fn add_executor(&mut self, _pubkey: &Pubkey, _executor: Arc<dyn Executor>) {}
-        fn get_executor(&mut self, _pubkey: &Pubkey) -> Option<Arc<dyn Executor>> {
-            None
-        }
-        fn record_instruction(&self, _instruction: &Instruction) {}
-        fn is_feature_active(&self, _feature_id: &Pubkey) -> bool {
-            true
-        }
-    }
-
     struct TestInstructionMeter {
         remaining: u64,
     }

programs/bpf_loader/src/syscalls.rs

@@ -1237,7 +1237,7 @@ fn call<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tests::{MockComputeMeter, MockLogger};
+    use solana_runtime::bpf_test_utils::{MockComputeMeter, MockLogger};
     use solana_sdk::hash::hashv;
     use std::str::FromStr;