Blockstore test cleanup (#19656)

* Use auto-deleting macro for ledger path

ledger/src/ancestor_iterator.rs

@@ -79,8 +79,8 @@ mod tests {
     use std::{collections::HashMap, path::Path};
     use trees::tr;
 
-    fn setup_forks(blockstore_path: &Path) -> Blockstore {
-        let blockstore = Blockstore::open(blockstore_path).unwrap();
+    fn setup_forks(ledger_path: &Path) -> Blockstore {
+        let blockstore = Blockstore::open(ledger_path).unwrap();
         /*
             Build fork structure:
 
@@ -102,28 +102,25 @@ mod tests {
 
     #[test]
     fn test_ancestor_iterator() {
-        let blockstore_path = get_tmp_ledger_path!();
-        {
-            let blockstore = setup_forks(&blockstore_path);
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = setup_forks(ledger_path.path());
 
-            // Test correctness
-            assert!(AncestorIterator::new(0, &blockstore).next().is_none());
-            assert_eq!(
-                AncestorIterator::new(4, &blockstore).collect::<Vec<Slot>>(),
-                vec![1, 0]
-            );
-            assert_eq!(
-                AncestorIterator::new(3, &blockstore).collect::<Vec<Slot>>(),
-                vec![2, 1, 0]
-            );
-        }
-        Blockstore::destroy(&blockstore_path).unwrap();
+        // Test correctness
+        assert!(AncestorIterator::new(0, &blockstore).next().is_none());
+        assert_eq!(
+            AncestorIterator::new(4, &blockstore).collect::<Vec<Slot>>(),
+            vec![1, 0]
+        );
+        assert_eq!(
+            AncestorIterator::new(3, &blockstore).collect::<Vec<Slot>>(),
+            vec![2, 1, 0]
+        );
     }
 
     #[test]
     fn test_ancestor_iterator_inclusive() {
-        let blockstore_path = get_tmp_ledger_path!();
-        let blockstore = Blockstore::open(&blockstore_path).unwrap();
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         let (shreds, _) = make_slot_entries(0, 0, 42);
         blockstore.insert_shreds(shreds, None, false).unwrap();
@@ -151,39 +148,36 @@ mod tests {
 
     #[test]
     fn test_ancestor_iterator_with_hash() {
-        let blockstore_path = get_tmp_ledger_path!();
-        {
-            let blockstore = setup_forks(&blockstore_path);
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = setup_forks(ledger_path.path());
 
-            // Insert frozen hashes
-            let mut slot_to_bank_hash = HashMap::new();
-            for slot in 0..=4 {
-                let bank_hash = Hash::new_unique();
-                slot_to_bank_hash.insert(slot, bank_hash);
-                blockstore.insert_bank_hash(slot, bank_hash, false);
-            }
-
-            // Test correctness
-            assert!(
-                AncestorIteratorWithHash::from(AncestorIterator::new(0, &blockstore))
-                    .next()
-                    .is_none()
-            );
-            assert_eq!(
-                AncestorIteratorWithHash::from(AncestorIterator::new(4, &blockstore))
-                    .collect::<Vec<(Slot, Hash)>>(),
-                vec![(1, slot_to_bank_hash[&1]), (0, slot_to_bank_hash[&0])]
-            );
-            assert_eq!(
-                AncestorIteratorWithHash::from(AncestorIterator::new(3, &blockstore))
-                    .collect::<Vec<(Slot, Hash)>>(),
-                vec![
-                    (2, slot_to_bank_hash[&2]),
-                    (1, slot_to_bank_hash[&1]),
-                    (0, slot_to_bank_hash[&0])
-                ]
-            );
+        // Insert frozen hashes
+        let mut slot_to_bank_hash = HashMap::new();
+        for slot in 0..=4 {
+            let bank_hash = Hash::new_unique();
+            slot_to_bank_hash.insert(slot, bank_hash);
+            blockstore.insert_bank_hash(slot, bank_hash, false);
         }
-        Blockstore::destroy(&blockstore_path).unwrap();
+
+        // Test correctness
+        assert!(
+            AncestorIteratorWithHash::from(AncestorIterator::new(0, &blockstore))
+                .next()
+                .is_none()
+        );
+        assert_eq!(
+            AncestorIteratorWithHash::from(AncestorIterator::new(4, &blockstore))
+                .collect::<Vec<(Slot, Hash)>>(),
+            vec![(1, slot_to_bank_hash[&1]), (0, slot_to_bank_hash[&0])]
+        );
+        assert_eq!(
+            AncestorIteratorWithHash::from(AncestorIterator::new(3, &blockstore))
+                .collect::<Vec<(Slot, Hash)>>(),
+            vec![
+                (2, slot_to_bank_hash[&2]),
+                (1, slot_to_bank_hash[&1]),
+                (0, slot_to_bank_hash[&0])
+            ]
+        );
     }
 }

ledger/src/blockstore_processor.rs

@@ -1522,9 +1522,8 @@ pub mod tests {
         genesis_config.poh_config.hashes_per_tick = Some(hashes_per_tick);
         let ticks_per_slot = genesis_config.ticks_per_slot;
 
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         let parent_slot = 0;
         let slot = 1;
@@ -1563,8 +1562,8 @@ pub mod tests {
         let ticks_per_slot = genesis_config.ticks_per_slot;
 
         // Create a new ledger with slot 0 full of ticks
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         // Write slot 1 with one tick missing
         let parent_slot = 0;
@@ -1626,8 +1625,8 @@ pub mod tests {
         } = create_genesis_config(10_000);
         let ticks_per_slot = genesis_config.ticks_per_slot;
 
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         let mut entries = create_ticks(ticks_per_slot, 0, blockhash);
         let trailing_entry = {
@@ -1685,11 +1684,10 @@ pub mod tests {
         */
 
         // Create a new ledger with slot 0 full of ticks
-        let (ledger_path, mut blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, mut blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
 
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         // Write slot 1
         // slot 1, points at slot 0.  Missing one tick
@@ -1759,7 +1757,7 @@ pub mod tests {
         let ticks_per_slot = genesis_config.ticks_per_slot;
 
         // Create a new ledger with slot 0 full of ticks
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
         let mut last_entry_hash = blockhash;
 
@@ -1777,8 +1775,7 @@ pub mod tests {
                    slot 4 <-- set_root(true)
 
         */
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         // Fork 1, ending at slot 3
         let last_slot1_entry_hash =
@@ -1838,7 +1835,7 @@ pub mod tests {
         let ticks_per_slot = genesis_config.ticks_per_slot;
 
         // Create a new ledger with slot 0 full of ticks
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
         let mut last_entry_hash = blockhash;
 
@@ -1856,8 +1853,7 @@ pub mod tests {
                    slot 4
 
         */
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         // Fork 1, ending at slot 3
         let last_slot1_entry_hash =
@@ -1926,7 +1922,7 @@ pub mod tests {
 
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let ticks_per_slot = genesis_config.ticks_per_slot;
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
 
         /*
@@ -1939,7 +1935,7 @@ pub mod tests {
                            \
                         slot 3
         */
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let slot1_blockhash =
             fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 1, 0, blockhash);
         fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 2, 1, slot1_blockhash);
@@ -1968,7 +1964,7 @@ pub mod tests {
 
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let ticks_per_slot = genesis_config.ticks_per_slot;
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
 
         /*
@@ -1981,7 +1977,7 @@ pub mod tests {
                /           \
            slot 4 (dead)   slot 3
         */
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let slot1_blockhash =
             fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 1, 0, blockhash);
         let slot2_blockhash =
@@ -2023,7 +2019,7 @@ pub mod tests {
 
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let ticks_per_slot = genesis_config.ticks_per_slot;
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
 
         /*
@@ -2032,7 +2028,7 @@ pub mod tests {
                 /          \
            slot 1 (dead)  slot 2 (dead)
         */
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 1, 0, blockhash);
         fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 2, 0, blockhash);
         blockstore.set_dead_slot(1).unwrap();
@@ -2053,11 +2049,10 @@ pub mod tests {
         let ticks_per_slot = genesis_config.ticks_per_slot;
 
         // Create a new ledger with slot 0 full of ticks
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
         let mut last_entry_hash = blockhash;
 
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         // Let `last_slot` be the number of slots in the first two epochs
         let epoch_schedule = get_epoch_schedule(&genesis_config, Vec::new());
@@ -2178,7 +2173,8 @@ pub mod tests {
             ..
         } = create_genesis_config_with_leader(mint, &leader_pubkey, 50);
         genesis_config.poh_config.hashes_per_tick = Some(hashes_per_tick);
-        let (ledger_path, mut last_entry_hash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, mut last_entry_hash) =
+            create_new_tmp_ledger_auto_delete!(&genesis_config);
         debug!("ledger_path: {:?}", ledger_path);
 
         let deducted_from_mint = 3;
@@ -2212,8 +2208,7 @@ pub mod tests {
         ));
         let last_blockhash = entries.last().unwrap().hash;
 
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         blockstore
             .write_entries(
                 1,
@@ -2253,9 +2248,9 @@ pub mod tests {
             mut genesis_config, ..
         } = create_genesis_config(123);
         genesis_config.ticks_per_slot = 1;
-        let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, _blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
 
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let opts = ProcessOptions {
             poh_verify: true,
             accounts_db_test_hash_calculation: true,
@@ -2271,9 +2266,9 @@ pub mod tests {
     #[test]
     fn test_process_ledger_options_override_threads() {
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(123);
-        let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, _blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
 
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let opts = ProcessOptions {
             override_num_threads: Some(1),
             accounts_db_test_hash_calculation: true,
@@ -2288,9 +2283,9 @@ pub mod tests {
     #[test]
     fn test_process_ledger_options_full_leader_cache() {
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(123);
-        let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
+        let (ledger_path, _blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
 
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let opts = ProcessOptions {
             full_leader_cache: true,
             accounts_db_test_hash_calculation: true,
@@ -2308,9 +2303,8 @@ pub mod tests {
             mint_keypair,
             ..
         } = create_genesis_config(100);
-        let (ledger_path, last_entry_hash) = create_new_tmp_ledger!(&genesis_config);
-        let blockstore =
-            Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
+        let (ledger_path, last_entry_hash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let blockhash = genesis_config.hash();
         let keypairs = [Keypair::new(), Keypair::new(), Keypair::new()];
 
@@ -2988,8 +2982,8 @@ pub mod tests {
 
         // Create roots at slots 0, 1
         let forks = tr(0) / tr(1);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         blockstore.add_tree(
             forks,
             false,
@@ -3021,8 +3015,8 @@ pub mod tests {
 
         let ticks_per_slot = 1;
         genesis_config.ticks_per_slot = ticks_per_slot;
-        let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
 
         /*
           Build a blockstore in the ledger with the following fork structure:
@@ -3615,8 +3609,8 @@ pub mod tests {
                 vec![100],
             );
         let ticks_per_slot = genesis_config.ticks_per_slot();
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Blockstore::open(&ledger_path).unwrap();
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         blockstore.add_tree(forks, false, true, ticks_per_slot, genesis_config.hash());
 
         if let Some(blockstore_root) = blockstore_root {

ledger/src/leader_schedule_cache.rs

@@ -255,7 +255,7 @@ mod tests {
             bootstrap_validator_stake_lamports, create_genesis_config,
             create_genesis_config_with_leader, GenesisConfigInfo,
         },
-        get_tmp_ledger_path,
+        get_tmp_ledger_path_auto_delete,
         staking_utils::tests::setup_vote_and_stake_accounts,
     };
     use solana_runtime::bank::Bank;
@@ -428,75 +428,71 @@ mod tests {
 
         let bank = Bank::new_for_tests(&genesis_config);
         let cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
-        let ledger_path = get_tmp_ledger_path!();
-        {
-            let blockstore = Arc::new(
-                Blockstore::open(&ledger_path)
-                    .expect("Expected to be able to open database ledger"),
-            );
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
 
-            assert_eq!(
-                cache.slot_leader_at(bank.slot(), Some(&bank)).unwrap(),
-                pubkey
-            );
-            // Check that the next leader slot after 0 is slot 1
-            assert_eq!(
-                cache
-                    .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
-                    .unwrap()
-                    .0,
-                1
-            );
+        let blockstore = Blockstore::open(ledger_path.path())
+            .expect("Expected to be able to open database ledger");
 
-            // Write a shred into slot 2 that chains to slot 1,
-            // but slot 1 is empty so should not be skipped
-            let (shreds, _) = make_slot_entries(2, 1, 1);
-            blockstore.insert_shreds(shreds, None, false).unwrap();
-            assert_eq!(
-                cache
-                    .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
-                    .unwrap()
-                    .0,
-                1
-            );
+        assert_eq!(
+            cache.slot_leader_at(bank.slot(), Some(&bank)).unwrap(),
+            pubkey
+        );
+        // Check that the next leader slot after 0 is slot 1
+        assert_eq!(
+            cache
+                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
+                .unwrap()
+                .0,
+            1
+        );
 
-            // Write a shred into slot 1
-            let (shreds, _) = make_slot_entries(1, 0, 1);
+        // Write a shred into slot 2 that chains to slot 1,
+        // but slot 1 is empty so should not be skipped
+        let (shreds, _) = make_slot_entries(2, 1, 1);
+        blockstore.insert_shreds(shreds, None, false).unwrap();
+        assert_eq!(
+            cache
+                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
+                .unwrap()
+                .0,
+            1
+        );
 
-            // Check that slot 1 and 2 are skipped
-            blockstore.insert_shreds(shreds, None, false).unwrap();
-            assert_eq!(
-                cache
-                    .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
-                    .unwrap()
-                    .0,
-                3
-            );
+        // Write a shred into slot 1
+        let (shreds, _) = make_slot_entries(1, 0, 1);
 
-            // Integrity checks
-            assert_eq!(
-                cache.next_leader_slot(
-                    &pubkey,
-                    2 * genesis_config.epoch_schedule.slots_per_epoch - 1, // no schedule generated for epoch 2
-                    &bank,
-                    Some(&blockstore),
-                    std::u64::MAX
-                ),
-                None
-            );
+        // Check that slot 1 and 2 are skipped
+        blockstore.insert_shreds(shreds, None, false).unwrap();
+        assert_eq!(
+            cache
+                .next_leader_slot(&pubkey, 0, &bank, Some(&blockstore), std::u64::MAX)
+                .unwrap()
+                .0,
+            3
+        );
 
-            assert_eq!(
-                cache.next_leader_slot(
-                    &solana_sdk::pubkey::new_rand(), // not in leader_schedule
-                    0,
-                    &bank,
-                    Some(&blockstore),
-                    std::u64::MAX
-                ),
-                None
-            );
-        }
-        Blockstore::destroy(&ledger_path).unwrap();
+        // Integrity checks
+        assert_eq!(
+            cache.next_leader_slot(
+                &pubkey,
+                2 * genesis_config.epoch_schedule.slots_per_epoch - 1, // no schedule generated for epoch 2
+                &bank,
+                Some(&blockstore),
+                std::u64::MAX
+            ),
+            None
+        );
+
+        assert_eq!(
+            cache.next_leader_slot(
+                &solana_sdk::pubkey::new_rand(), // not in leader_schedule
+                0,
+                &bank,
+                Some(&blockstore),
+                std::u64::MAX
+            ),
+            None
+        );
     }
 
     #[test]

ledger/src/next_slots_iterator.rs

@@ -41,8 +41,8 @@ mod tests {
 
     #[test]
     fn test_next_slots_iterator() {
-        let blockstore_path = get_tmp_ledger_path!();
-        let blockstore = Blockstore::open(&blockstore_path).unwrap();
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         blockstore.set_roots(std::iter::once(&0)).unwrap();
         let ticks_per_slot = 5;
         /*
@@ -107,8 +107,5 @@ mod tests {
             .collect();
         let expected = vec![4].into_iter().collect();
         assert_eq!(result, expected);
-
-        drop(blockstore);
-        Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
     }
 }

ledger/src/rooted_slot_iterator.rs

@@ -82,8 +82,8 @@ mod tests {
 
     #[test]
     fn test_rooted_slot_iterator() {
-        let blockstore_path = get_tmp_ledger_path!();
-        let blockstore = Blockstore::open(&blockstore_path).unwrap();
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         blockstore.set_roots(std::iter::once(&0)).unwrap();
         let ticks_per_slot = 5;
         /*
@@ -150,15 +150,12 @@ mod tests {
             .collect();
         let expected = vec![0, 1, 2, 3];
         assert_eq!(result, expected);
-
-        drop(blockstore);
-        Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
     }
 
     #[test]
     fn test_skipping_rooted_slot_iterator() {
-        let blockstore_path = get_tmp_ledger_path!();
-        let blockstore = Blockstore::open(&blockstore_path).unwrap();
+        let ledger_path = get_tmp_ledger_path_auto_delete!();
+        let blockstore = Blockstore::open(ledger_path.path()).unwrap();
         let ticks_per_slot = 5;
         /*
             Build a blockstore in the ledger with the following fork structure:
@@ -229,8 +226,5 @@ mod tests {
             (11, true),
         ];
         assert_eq!(result, expected);
-
-        drop(blockstore);
-        Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
     }
 }

ledger/tests/blockstore.rs

@@ -1,7 +1,7 @@
 use solana_entry::entry;
 use solana_ledger::{
     blockstore::{self, Blockstore},
-    get_tmp_ledger_path,
+    get_tmp_ledger_path_auto_delete,
 };
 use solana_sdk::hash::Hash;
 use std::sync::Arc;
@@ -9,8 +9,8 @@ use std::thread::Builder;
 
 #[test]
 fn test_multiple_threads_insert_shred() {
-    let blockstore_path = get_tmp_ledger_path!();
-    let blockstore = Arc::new(Blockstore::open(&blockstore_path).unwrap());
+    let ledger_path = get_tmp_ledger_path_auto_delete!();
+    let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
 
     for _ in 0..100 {
         let num_threads = 10;
@@ -44,8 +44,4 @@ fn test_multiple_threads_insert_shred() {
         // Delete slots for next iteration
         blockstore.purge_and_compact_slots(0, num_threads + 1);
     }
-
-    // Cleanup
-    drop(blockstore);
-    Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
 }