blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Blockstore test cleanup (#19656) 

* Use auto-deleting macro for ledger path
This commit is contained in:
steviez 2021-09-10 07:33:08 -05:00 committed by GitHub
parent 311b5789af
commit 2dee098b91
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 3795 additions and 3954 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
ledger/src/ancestor_iterator.rs
View File

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

6297
ledger/src/blockstore.rs
View File

File diff suppressed because it is too large Load Diff

1121
ledger/src/blockstore/blockstore_purge.rs
View File

File diff suppressed because it is too large Load Diff

80
ledger/src/blockstore_processor.rs
View File

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

124
ledger/src/leader_schedule_cache.rs
View File

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

7
ledger/src/next_slots_iterator.rs
View File

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

14
ledger/src/rooted_slot_iterator.rs
View File

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

10
ledger/tests/blockstore.rs
View File

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