Added tests for is_empty fix

Author: mrLSD

evm/src/executor/stack/memory.rs

@@ -740,3 +740,160 @@ impl<'backend, 'config, B: Backend> MemoryStackState<'backend, 'config, B> {
         self.substate.deposit(address, value, self.backend);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::backend::{Backend, MemoryAccount, MemoryBackend, MemoryVicinity};
+    use crate::executor::stack::executor::StackSubstateMetadata;
+    use crate::executor::stack::memory::MemoryStackState;
+    use crate::executor::stack::StackState;
+    use crate::prelude::*;
+    use crate::Config;
+    use primitive_types::{H160, U256};
+
+    fn memory_vicinity() -> MemoryVicinity {
+        MemoryVicinity {
+            gas_price: U256::from(1),
+            effective_gas_price: Default::default(),
+            origin: H160::zero(),
+            block_hashes: Vec::new(),
+            block_number: U256::zero(),
+            block_coinbase: H160::zero(),
+            block_timestamp: U256::zero(),
+            block_difficulty: U256::zero(),
+            block_randomness: None,
+            blob_gas_price: None,
+            block_gas_limit: U256::from(30_000_000),
+            block_base_fee_per_gas: U256::from(1),
+            chain_id: U256::from(1),
+            blob_hashes: vec![],
+        }
+    }
+
+    #[test]
+    fn test_is_empty_catch_backend_only() {
+        let mut state = BTreeMap::new();
+
+        let addr1 = H160::from_low_u64_be(1);
+        state.insert(
+            addr1,
+            MemoryAccount {
+                balance: U256::one(),
+                nonce: U256::zero(),
+                storage: BTreeMap::new(),
+                code: Vec::new(),
+            },
+        );
+
+        let addr2 = H160::from_low_u64_be(2);
+        state.insert(
+            addr2,
+            MemoryAccount {
+                balance: U256::zero(),
+                nonce: U256::one(),
+                storage: BTreeMap::new(),
+                code: Vec::new(),
+            },
+        );
+
+        let addr3 = H160::from_low_u64_be(3);
+        state.insert(
+            addr3,
+            MemoryAccount {
+                balance: U256::zero(),
+                nonce: U256::zero(),
+                storage: BTreeMap::new(),
+                code: vec![0x42],
+            },
+        );
+
+        let addr4 = H160::from_low_u64_be(4);
+        state.insert(
+            addr4,
+            MemoryAccount {
+                balance: U256::zero(),
+                nonce: U256::zero(),
+                storage: BTreeMap::new(),
+                code: Vec::new(),
+            },
+        );
+
+        let vicinity = memory_vicinity();
+        let backend = MemoryBackend::new(&vicinity, state);
+        let config = Config::osaka();
+        let metadata = StackSubstateMetadata::new(0, &config);
+
+        let stack_state = MemoryStackState::new(metadata, &backend);
+
+        assert!(!stack_state.is_empty(addr1));
+        assert!(!stack_state.is_empty(addr2));
+        assert!(!stack_state.is_empty(addr3));
+        assert!(stack_state.is_empty(addr4));
+    }
+
+    #[test]
+    fn test_is_empty_with_cached_account() {
+        let mut state = BTreeMap::new();
+
+        let addr1 = H160::from_low_u64_be(1);
+        state.insert(
+            addr1,
+            MemoryAccount {
+                balance: U256::zero(),
+                nonce: U256::zero(),
+                storage: BTreeMap::new(),
+                code: Vec::new(),
+            },
+        );
+
+        let addr2 = H160::from_low_u64_be(2);
+        state.insert(
+            addr2,
+            MemoryAccount {
+                balance: U256::zero(),
+                nonce: U256::zero(),
+                storage: BTreeMap::new(),
+                code: vec![0x42],
+            },
+        );
+
+        let vicinity = memory_vicinity();
+        let backend = MemoryBackend::new(&vicinity, state);
+        let config = Config::osaka();
+        let metadata = StackSubstateMetadata::new(0, &config);
+
+        let mut stack_state = MemoryStackState::new(metadata, &backend);
+        assert!(stack_state.is_empty(addr1));
+        assert!(!stack_state.is_empty(addr2));
+
+        // Accounts cached
+        stack_state.deposit(addr1, U256::one());
+        stack_state.deposit(addr2, U256::one());
+        // Cached account
+        assert!(!stack_state.is_empty(addr1));
+
+        // Ensure that code will pass `is_some` check to catch data from backend.
+        let acc1 = stack_state.substate.accounts.get(&addr1).unwrap();
+        let acc2 = stack_state.substate.accounts.get(&addr2).unwrap();
+        assert_eq!(acc1.basic.balance, U256::one());
+        assert!(acc1.code.is_none());
+        assert_eq!(acc2.basic.balance, U256::one());
+        // NOTE: code is not cached
+        assert!(acc2.code.is_none());
+
+        stack_state.reset_balance(addr1);
+        // Get from cache and code from backend.
+        assert!(stack_state.is_empty(addr1));
+        assert!(stack_state.code(addr1).is_empty());
+
+        stack_state.reset_balance(addr2);
+        let acc2 = stack_state.substate.accounts.get(&addr2).unwrap();
+        assert_eq!(acc2.basic.balance, U256::zero());
+        // NOTE: code is not cached
+        assert!(acc2.code.is_none());
+        // Get code from backend, but in backend code is not empty, so account is not empty.
+        assert!(!stack_state.is_empty(addr2));
+        // Get code from backend, but in backend code is not empty
+        assert_eq!(stack_state.code(addr2), vec![0x42]);
+    }
+}