Fix stack_flush_test (#333)

Author: azarovh

Cargo.lock

@@ -17,5 +17,6 @@ thiserror = "1.0"
 
 [dev-dependencies]
 crypto = { path = '../crypto' }
-
 itertools = "0.10"
+rstest = "0.15"
+test-utils = {path = '../test-utils'}

utxo/Cargo.toml

@@ -75,12 +75,17 @@ impl BlockUndo {
 pub mod test {
     use super::*;
     use crate::test_helper::create_utxo;
-    use crypto::random::{make_pseudo_rng, Rng};
-
-    #[test]
-    fn tx_undo_test() {
-        let (utxo0, _) = create_utxo(0);
-        let (utxo1, _) = create_utxo(1);
+    use crypto::random::Rng;
+    use rstest::rstest;
+    use test_utils::random::{make_seedable_rng, Seed};
+
+    #[rstest]
+    #[trace]
+    #[case(Seed::from_entropy())]
+    fn tx_undo_test(#[case] seed: Seed) {
+        let mut rng = make_seedable_rng(seed);
+        let (utxo0, _) = create_utxo(&mut rng, 0);
+        let (utxo1, _) = create_utxo(&mut rng, 1);
         let mut tx_undo = TxUndo::new(vec![utxo0.clone()]);
 
         // check push
@@ -102,16 +107,19 @@ pub mod test {
         }
     }
 
-    #[test]
-    fn block_undo_test() {
+    #[rstest]
+    #[trace]
+    #[case(Seed::from_entropy())]
+    fn block_undo_test(#[case] seed: Seed) {
+        let mut rng = make_seedable_rng(seed);
         let expected_height = BlockHeight::new(5);
-        let (utxo0, _) = create_utxo(0);
-        let (utxo1, _) = create_utxo(1);
+        let (utxo0, _) = create_utxo(&mut rng, 0);
+        let (utxo1, _) = create_utxo(&mut rng, 1);
         let tx_undo0 = TxUndo::new(vec![utxo0, utxo1]);
 
-        let (utxo2, _) = create_utxo(2);
-        let (utxo3, _) = create_utxo(3);
-        let (utxo4, _) = create_utxo(4);
+        let (utxo2, _) = create_utxo(&mut rng, 2);
+        let (utxo3, _) = create_utxo(&mut rng, 3);
+        let (utxo4, _) = create_utxo(&mut rng, 4);
         let tx_undo1 = TxUndo::new(vec![utxo2, utxo3, utxo4]);
 
         let blockundo = BlockUndo::new(vec![tx_undo0.clone(), tx_undo1.clone()], expected_height);

utxo/src/undo.rs

@@ -448,10 +448,9 @@ impl<'a> UtxosView for UtxosCache<'a> {
 impl<'a> FlushableUtxoView for UtxosCache<'a> {
     fn batch_write(&mut self, utxo_entries: ConsumedUtxoCache) -> Result<(), Error> {
         for (key, entry) in utxo_entries.container {
-            let parent_entry = self.utxos.get(&key);
-
             // Ignore non-dirty entries (optimization).
             if entry.is_dirty {
+                let parent_entry = self.utxos.get(&key);
                 match parent_entry {
                     None => {
                         // The parent cache does not have an entry, while the child cache does.
@@ -516,35 +515,44 @@ mod simulation;
 #[cfg(test)]
 mod unit_test {
     use common::primitives::H256;
+    use rstest::rstest;
+    use test_utils::random::{make_seedable_rng, Seed};
 
     use crate::test_helper::{insert_single_entry, Presence, DIRTY, FRESH};
     use crate::UtxosCache;
 
-    #[test]
-    fn test_uncache() {
+    #[rstest]
+    #[trace]
+    #[case(Seed::from_entropy())]
+    fn test_uncache(#[case] seed: Seed) {
+        let mut rng = make_seedable_rng(seed);
         let mut cache = UtxosCache::new_for_test(H256::random().into());
 
         // when the entry is not dirty and not fresh
-        let (utxo, outp) = insert_single_entry(&mut cache, &Presence::Present, Some(0), None);
+        let (utxo, outp) =
+            insert_single_entry(&mut rng, &mut cache, &Presence::Present, Some(0), None);
         let res = cache.uncache(&outp).expect("should return an entry");
         assert_eq!(res.utxo(), Some(utxo));
         assert!(!cache.has_utxo_in_cache(&outp));
 
         // when the outpoint does not exist.
-        let (_, outp) = insert_single_entry(&mut cache, &Presence::Absent, None, None);
+        let (_, outp) = insert_single_entry(&mut rng, &mut cache, &Presence::Absent, None, None);
         assert_eq!(cache.uncache(&outp), None);
         assert!(!cache.has_utxo_in_cache(&outp));
 
         // when the entry is fresh, entry cannot be removed.
-        let (_, outp) = insert_single_entry(&mut cache, &Presence::Present, Some(FRESH), None);
+        let (_, outp) =
+            insert_single_entry(&mut rng, &mut cache, &Presence::Present, Some(FRESH), None);
         assert_eq!(cache.uncache(&outp), None);
 
         // when the entry is dirty, entry cannot be removed.
-        let (_, outp) = insert_single_entry(&mut cache, &Presence::Present, Some(DIRTY), None);
+        let (_, outp) =
+            insert_single_entry(&mut rng, &mut cache, &Presence::Present, Some(DIRTY), None);
         assert_eq!(cache.uncache(&outp), None);
 
         // when the entry is both fresh and dirty, entry cannot be removed.
-        let (_, outp) = insert_single_entry(&mut cache, &Presence::Present, Some(FRESH), None);
+        let (_, outp) =
+            insert_single_entry(&mut rng, &mut cache, &Presence::Present, Some(FRESH), None);
         assert_eq!(cache.uncache(&outp), None);
     }
 }