fix fmt

Author: federico-stacks

_test/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "_test"
+version = "0.0.1"
+edition = "2021"
+resolver = "2"
+
+[dependencies]
+stacks_common = { package = "stacks-common", path = "../stacks-common", default-features = false }
+stacks_lib = { package = "stackslib", path = "../stackslib", features = ["testing"] }
+

_test/src/main.rs

@@ -0,0 +1,213 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::{Cursor, Seek, Write};
+
+    use stacks_lib::chainstate::stacks::index::node::*;
+    use stacks_lib::codec::*;
+
+    #[test]
+    fn test_trienode_patch_try_from_nodetype_returns_none_when_no_diffs() {
+        let node = TrieNodeType::Node4(TrieNode4::new(&[1]));
+
+        let old_node_ptr = TriePtr::default();
+        let old_node = &node;
+        let new_node = &node;
+        let result = TrieNodePatch::try_from_nodetype(old_node_ptr, old_node, new_node);
+
+        assert!(
+            result.is_none(),
+            "None because the computed patch has no diffs"
+        );
+    }
+
+    #[test]
+    fn test_trienode_patch_try_from_patch_returns_none_when_no_diffs() {
+        let old_patch_ptr = TriePtr::new(TrieNodeID::Node4 as u8, 0, 0);
+        let old_patch = TrieNodePatch {
+            ptr: old_patch_ptr.clone(),
+            ptr_diff: vec![],
+        };
+        let new_node = TrieNodeType::Node4(TrieNode4::new(&[1]));
+        let result = TrieNodePatch::try_from_patch(old_patch_ptr, &old_patch, &new_node);
+
+        assert!(
+            result.is_none(),
+            "None because the computed patch has no diffs"
+        );
+    }
+
+    /*
+    #[test]
+    fn test_trienode_patch_serialize_with_ptr_diffs_length_0_ok() {
+        let a_ptr = TriePtr::new(0,0, 0);
+        let patch_err = TrieNodePatch {
+            ptr: a_ptr,
+            ptr_diff: vec![],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        let result = patch_err.consensus_serialize(&mut buffer);
+        assert!(result.is_ok(), "Got Error: {}", result.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_trienode_patch_serialize_with_ptr_diffs_length_255_ok() {
+        let a_ptr = TriePtr::new(0,0, 0);
+        let patch_err = TrieNodePatch {
+            ptr: a_ptr,
+            ptr_diff: vec![a_ptr.clone(); 255],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        let result = patch_err.consensus_serialize(&mut buffer);
+        assert!(result.is_ok(), "Got Error: {}", result.unwrap_err().to_string());
+    }
+
+
+    #[test]
+    fn test_trienode_patch_serialize_with_ptr_diffs_length_256_fails() {
+        let a_ptr = TriePtr::new(0,0, 0);
+        let patch_err = TrieNodePatch {
+            ptr: a_ptr,
+            ptr_diff: vec![a_ptr.clone(); 256],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        let result = patch_err.consensus_serialize(&mut buffer);
+
+        let error = result.unwrap_err();
+        assert!(matches!(error, Error::SerializeError(_)));
+        assert!(error.to_string().contains("256"));
+    }
+     */
+
+    #[test]
+    fn test_trienode_patch_serialize_ok() {
+        let patch_node = TrieNodePatch {
+            ptr: TriePtr::new(1, 10, 0),
+            ptr_diff: vec![TriePtr::new(1, 20, 0).clone(); 1],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        patch_node
+            .consensus_serialize(&mut buffer)
+            .expect("serialization should be ok");
+
+        // To fit in 1 byte, diff count is serialized 0-based (where 0 => 1 and 255 => 256)
+        let diff_count = 0u8;
+        assert_eq!(
+            vec![6, 65, 10, 0, 0, 0, 0, diff_count, 65, 20, 0, 0, 0, 0],
+            buffer.into_inner(),
+        );
+    }
+
+    #[test]
+    fn test_trienode_patch_serialize_fails_with_ptr_diffs_len_0() {
+        let patch_node = TrieNodePatch {
+            ptr: TriePtr::default(),
+            ptr_diff: vec![],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        let error = patch_node
+            .consensus_serialize(&mut buffer)
+            .expect_err("serialization should fail");
+
+        assert!(
+            matches!(&error, Error::SerializeError(msg) if msg.contains("len 0")),
+            "instead got: {error}"
+        );
+    }
+
+    #[test]
+    fn test_trienode_patch_serialize_ok_with_ptr_diffs_len_256() {
+        let patch_node = TrieNodePatch {
+            ptr: TriePtr::default(),
+            ptr_diff: vec![TriePtr::default(); 256],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        let result = patch_node.consensus_serialize(&mut buffer);
+        assert!(
+            result.is_ok(),
+            "Got Error: {}",
+            result.unwrap_err().to_string()
+        );
+    }
+
+    #[test]
+    fn test_trienode_patch_serialize_fails_with_ptr_diffs_len_257() {
+        let patch_node = TrieNodePatch {
+            ptr: TriePtr::default(),
+            ptr_diff: vec![TriePtr::default(); 257],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        let error = patch_node
+            .consensus_serialize(&mut buffer)
+            .expect_err("serialization should fail");
+
+        assert!(
+            matches!(&error, Error::SerializeError(msg) if msg.contains("len 257")),
+            "instead got: {error}"
+        );
+    }
+
+    #[test]
+    fn test_trienode_patch_deserialize_ok_with_ptr_diffs_len_1() {
+        let mut buffer = Cursor::new(Vec::new());
+        // To fit in 1 byte, diff count is serialized 0-based (where 0 => 1 and 255 => 256)
+        let diff_count = 0u8;
+        buffer
+            .write_all(&[6, 65, 10, 0, 0, 0, 0, diff_count, 65, 20, 0, 0, 0, 0])
+            .unwrap();
+        buffer.rewind().unwrap();
+
+        let patch_node = TrieNodePatch::consensus_deserialize(&mut buffer)
+            .expect("deserialization should be ok");
+
+        let expected = TrieNodePatch {
+            ptr: TriePtr::new(1, 10, 0),
+            ptr_diff: vec![TriePtr::new(1, 20, 0); 1],
+        };
+        assert_eq!(expected, patch_node);
+    }
+
+    #[test]
+    fn test_trienode_patch_prova() {
+        let patch_node = TrieNodePatch {
+            ptr: TriePtr::new(1, 10, 0),
+            ptr_diff: vec![TriePtr::new(1, 20, 0).clone(); 1],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        patch_node
+            .consensus_serialize(&mut buffer)
+            .expect("serialization should be ok");
+
+        println!("Simple: {:?}", buffer.into_inner());
+
+
+        let back_id = set_backptr(1);
+        let mut ptr = TriePtr::new(back_id, 10, 0);
+        ptr.back_block = 99;
+
+        let patch_node = TrieNodePatch {
+            ptr: ptr,
+            ptr_diff: vec![TriePtr::new(1, 20, 0).clone(); 1],
+        };
+
+        let mut buffer = Cursor::new(Vec::new());
+        patch_node
+            .consensus_serialize(&mut buffer)
+            .expect("serialization should be ok");
+
+        println!("Bimple: {:?}", buffer.into_inner());
+
+
+    }
+}

stacks-node/src/tests/marf/marf_mixed.rs

@@ -14,16 +14,25 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 pub mod utils {
+    use std::env;
+    use std::time::Instant;
+
     use clarity::vm::types::PrincipalData;
     use rusqlite::Connection;
-    use stacks::{chainstate::burn::db::sortdb::SortitionDB, clarity_vm::database::marf::fault_injection_marf_compression, core::{mempool::MemPoolWalkStrategy, test_util::{insert_tx_in_mempool, make_stacks_transfer_serialized}}, types::chainstate::{StacksAddress, StacksPrivateKey}};
+    use stacks::chainstate::burn::db::sortdb::SortitionDB;
+    use stacks::clarity_vm::database::marf::fault_injection_marf_compression;
+    use stacks::core::mempool::MemPoolWalkStrategy;
+    use stacks::core::test_util::{insert_tx_in_mempool, make_stacks_transfer_serialized};
+    use stacks::types::chainstate::{StacksAddress, StacksPrivateKey};
     use stacks_signer::v0::SpawnedSigner;
 
-    use crate::{nakamoto_node::miner::{fault_injection_stall_miner, fault_injection_unstall_miner}, tests::{self, nakamoto_integrations::wait_for, neon_integrations::{get_account, test_observer}, signer::SignerTest}};
-    use std::time::Instant;
-    use std::env;
+    use crate::nakamoto_node::miner::{fault_injection_stall_miner, fault_injection_unstall_miner};
+    use crate::tests::nakamoto_integrations::wait_for;
+    use crate::tests::neon_integrations::{get_account, test_observer};
+    use crate::tests::signer::SignerTest;
+    use crate::tests::{self};
 
-    pub fn large_mempool_base(marf_compress_step1: bool, marf_compress_step2: bool,) {
+    pub fn large_mempool_base(marf_compress_step1: bool, marf_compress_step2: bool) {
         // This function intends to check the timing of the mempool iteration when
         // there are a large number of transactions in the mempool. It will boot to
         // epoch 3, fan out some STX transfers to a large number of accounts, wait for
@@ -41,7 +50,7 @@ pub mod utils {
         }
 
         let strategy = MemPoolWalkStrategy::GlobalFeeRate;
-        let set_fee = || { 180 };
+        let set_fee = || 180;
 
         // Set marf compression at the beginning
         fault_injection_marf_compression(marf_compress_step1);
@@ -167,7 +176,6 @@ pub mod utils {
         // Add the new senders to the list of senders
         senders.extend(new_senders.iter().map(|sk| (sk, 0)));
 
-
         info!("Sending the second round of funding");
         // Set marf compression before starting second round
         fault_injection_marf_compression(marf_compress_step2);
@@ -241,8 +249,9 @@ pub mod utils {
                 let sender_addr = tests::to_addr(sender_sk);
                 let fee = set_fee();
                 assert!(fee >= 180 && fee <= 2000);
-                let transfer_tx =
-                    make_stacks_transfer_serialized(sender_sk, *nonce, fee, chain_id, &recipient, 1);
+                let transfer_tx = make_stacks_transfer_serialized(
+                    sender_sk, *nonce, fee, chain_id, &recipient, 1,
+                );
                 insert_tx_in_mempool(
                     &db_tx,
                     transfer_tx,

stacks-node/src/tests/marf/mod.rs

@@ -17,9 +17,9 @@
 //!
 //! Entry point for MARF integration tests that validate
 //! behavior and interactions involving compression feature.
-//! 
+//!
 //! Possibly these kind of tests can be deleted once will have chainstate snapshots
 //! with full MARF compression.
+mod marf_compress;
 mod marf_mixed;
 mod marf_no_compress;
-mod marf_compress;