gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

9951 clippy errors in the test suite (#10030)

Browse Source 
automerge
This commit is contained in:
Kristofer Peterson
2020-05-15 17:35:43 +01:00
committed by GitHub
parent 1da1667920
commit 58ef02f02b
106 changed files with 713 additions and 827 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ledger/src/bank_forks.rs
View File

@ -402,7 +402,7 @@ mod tests {
assert_eq!(bank_forks.root(), 0);
assert_eq!(bank_forks.working_bank().slot(), 1);
let bank_forks = BankForks::new_from_banks(&[child_bank.clone(), bank.clone()], 0);
let bank_forks = BankForks::new_from_banks(&[child_bank, bank], 0);
assert_eq!(bank_forks.root(), 0);
assert_eq!(bank_forks.working_bank().slot(), 1);
}

67
ledger/src/blockstore.rs
View File

@ -4085,6 +4085,7 @@ pub mod tests {
}
#[test]
#[allow(clippy::cognitive_complexity)]
pub fn test_forward_chaining_is_connected() {
let blockstore_path = get_tmp_ledger_path!();
{
@ -4284,7 +4285,7 @@ pub mod tests {
let blockstore = Blockstore::open(&blockstore_path).unwrap();
// Slot doesn't exist
assert!(blockstore.get_slots_since(&vec![0]).unwrap().is_empty());
assert!(blockstore.get_slots_since(&[0]).unwrap().is_empty());
let mut meta0 = SlotMeta::new(0, 0);
blockstore.meta_cf.put(0, &meta0).unwrap();
@ -4292,25 +4293,22 @@ pub mod tests {
// Slot exists, chains to nothing
let expected: HashMap<u64, Vec<u64>> =
HashMap::from_iter(vec![(0, vec![])].into_iter());
assert_eq!(blockstore.get_slots_since(&vec![0]).unwrap(), expected);
assert_eq!(blockstore.get_slots_since(&[0]).unwrap(), expected);
meta0.next_slots = vec![1, 2];
blockstore.meta_cf.put(0, &meta0).unwrap();
// Slot exists, chains to some other slots
let expected: HashMap<u64, Vec<u64>> =
HashMap::from_iter(vec![(0, vec![1, 2])].into_iter());
assert_eq!(blockstore.get_slots_since(&vec![0]).unwrap(), expected);
assert_eq!(blockstore.get_slots_since(&vec![0, 1]).unwrap(), expected);
assert_eq!(blockstore.get_slots_since(&[0]).unwrap(), expected);
assert_eq!(blockstore.get_slots_since(&[0, 1]).unwrap(), expected);
let mut meta3 = SlotMeta::new(3, 1);
meta3.next_slots = vec![10, 5];
blockstore.meta_cf.put(3, &meta3).unwrap();
let expected: HashMap<u64, Vec<u64>> =
HashMap::from_iter(vec![(0, vec![1, 2]), (3, vec![10, 5])].into_iter());
assert_eq!(
blockstore.get_slots_since(&vec![0, 1, 3]).unwrap(),
expected
);
assert_eq!(blockstore.get_slots_since(&[0, 1, 3]).unwrap(), expected);
}
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
@ -4899,11 +4897,8 @@ pub mod tests {
// Trying to insert value into slot <= than last root should fail
{
let mut coding_shred = Shred::new_empty_from_header(
shred.clone(),
DataShredHeader::default(),
coding.clone(),
);
let mut coding_shred =
Shred::new_empty_from_header(shred, DataShredHeader::default(), coding);
let index = index_cf.get(coding_shred.slot()).unwrap().unwrap();
coding_shred.set_slot(*last_root.read().unwrap());
assert!(!Blockstore::should_insert_coding_shred(
@ -5022,7 +5017,7 @@ pub mod tests {
.unwrap();
for ((slot, _), _) in data_iter {
if slot > 5 {
assert!(false);
panic!();
}
}
@ -5051,7 +5046,7 @@ pub mod tests {
.slot_meta_iterator(0)
.unwrap()
.for_each(|(_, _)| {
assert!(false);
panic!();
});
drop(blockstore);
@ -5095,7 +5090,7 @@ pub mod tests {
blockstore
.slot_meta_iterator(5)
.unwrap()
.for_each(|_| assert!(false));
.for_each(|_| panic!());
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
@ -5479,7 +5474,7 @@ pub mod tests {
#[test]
fn test_get_block_timestamps() {
let vote_keypairs: Vec<Keypair> = (0..6).map(|_| Keypair::new()).collect();
let base_timestamp = 1576183541;
let base_timestamp = 1_576_183_541;
let mut expected_timestamps: Vec<(Pubkey, (Slot, UnixTimestamp))> = Vec::new();
// Populate slot 1 with vote transactions, some of which have timestamps
@ -5506,7 +5501,7 @@ pub mod tests {
let mut tick = create_ticks(1, 0, hash(&serialize(&i).unwrap()));
vote_entries.append(&mut tick);
}
let shreds = entries_to_test_shreds(vote_entries.clone(), 1, 0, true, 0);
let shreds = entries_to_test_shreds(vote_entries, 1, 0, true, 0);
let ledger_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&ledger_path).unwrap();
blockstore.insert_shreds(shreds, None, false).unwrap();
@ -5553,7 +5548,7 @@ pub mod tests {
#[test]
fn test_calculate_stake_weighted_timestamp() {
let recent_timestamp: UnixTimestamp = 1578909061;
let recent_timestamp: UnixTimestamp = 1_578_909_061;
let slot = 5;
let slot_duration = Duration::from_millis(400);
let expected_offset = (slot * slot_duration).as_secs();
@ -5738,6 +5733,7 @@ pub mod tests {
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_transaction_status_index() {
let blockstore_path = get_tmp_ledger_path!();
{
@ -5942,6 +5938,7 @@ pub mod tests {
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_purge_transaction_status() {
let blockstore_path = get_tmp_ledger_path!();
{
@ -6116,8 +6113,8 @@ pub mod tests {
let status = TransactionStatusMeta {
status: solana_sdk::transaction::Result::<()>::Ok(()),
fee: 42u64,
pre_balances: pre_balances_vec.clone(),
post_balances: post_balances_vec.clone(),
pre_balances: pre_balances_vec,
post_balances: post_balances_vec,
};
let signature1 = Signature::new(&[1u8; 64]);
@ -6132,46 +6129,46 @@ pub mod tests {
// signature4 in 2 non-roots,
// extra entries
transaction_status_cf
.put((0, signature2.clone(), 1), &status)
.put((0, signature2, 1), &status)
.unwrap();
transaction_status_cf
.put((0, signature2.clone(), 2), &status)
.put((0, signature2, 2), &status)
.unwrap();
transaction_status_cf
.put((0, signature4.clone(), 0), &status)
.put((0, signature4, 0), &status)
.unwrap();
transaction_status_cf
.put((0, signature4.clone(), 1), &status)
.put((0, signature4, 1), &status)
.unwrap();
transaction_status_cf
.put((0, signature5.clone(), 0), &status)
.put((0, signature5, 0), &status)
.unwrap();
transaction_status_cf
.put((0, signature5.clone(), 1), &status)
.put((0, signature5, 1), &status)
.unwrap();
// Initialize index 1, including:
// signature4 in non-root and root,
// extra entries
transaction_status_cf
.put((1, signature4.clone(), 1), &status)
.put((1, signature4, 1), &status)
.unwrap();
transaction_status_cf
.put((1, signature4.clone(), 2), &status)
.put((1, signature4, 2), &status)
.unwrap();
transaction_status_cf
.put((1, signature5.clone(), 0), &status)
.put((1, signature5, 0), &status)
.unwrap();
transaction_status_cf
.put((1, signature5.clone(), 1), &status)
.put((1, signature5, 1), &status)
.unwrap();
blockstore.set_roots(&[2]).unwrap();
@ -6508,8 +6505,8 @@ pub mod tests {
transactions.into_iter(),
);
assert_eq!(map.len(), 5);
for x in 0..4 {
assert_eq!(map[x].meta.as_ref().unwrap().fee, x as u64);
for (x, m) in map.iter().take(4).enumerate() {
assert_eq!(m.meta.as_ref().unwrap().fee, x as u64);
}
assert_eq!(map[4].meta, None);
}
@ -6771,8 +6768,8 @@ pub mod tests {
let entries1 = make_slot_entries_with_transactions(1);
let entries2 = make_slot_entries_with_transactions(1);
let leader_keypair = Arc::new(Keypair::new());
let shredder = Shredder::new(slot, 0, 1.0, leader_keypair.clone(), 0, 0)
.expect("Failed in creating shredder");
let shredder =
Shredder::new(slot, 0, 1.0, leader_keypair, 0, 0).expect("Failed in creating shredder");
let (shreds, _, _) = shredder.entries_to_shreds(&entries1, true, 0);
let (duplicate_shreds, _, _) = shredder.entries_to_shreds(&entries2, true, 0);
let shred = shreds[0].clone();

42
ledger/src/blockstore_processor.rs
View File

@ -1102,7 +1102,7 @@ pub mod tests {
..ProcessOptions::default()
};
let (bank_forks, _leader_schedule) =
process_blockstore(&genesis_config, &blockstore, Vec::new(), opts.clone()).unwrap();
process_blockstore(&genesis_config, &blockstore, Vec::new(), opts).unwrap();
assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); // slot 1 isn't "full", we stop at slot zero
@ -1197,8 +1197,8 @@ pub mod tests {
.parents()
.iter()
.map(|bank| bank.slot())
.collect::<Vec<_>>()
.is_empty());
.next()
.is_none());
// Ensure bank_forks holds the right banks
verify_fork_infos(&bank_forks);
@ -1488,8 +1488,8 @@ pub mod tests {
.parents()
.iter()
.map(|bank| bank.slot())
.collect::<Vec<_>>()
.is_empty());
.next()
.is_none());
}
#[test]
@ -1756,7 +1756,7 @@ pub mod tests {
// ensure bank can process a tick
assert_eq!(bank.tick_height(), 0);
let tick = next_entry(&genesis_config.hash(), 1, vec![]);
assert_eq!(process_entries(&bank, &[tick.clone()], true, None), Ok(()));
assert_eq!(process_entries(&bank, &[tick], true, None), Ok(()));
assert_eq!(bank.tick_height(), 1);
}
@ -2026,9 +2026,9 @@ pub mod tests {
assert!(process_entries(
&bank,
&[
entry_1_to_mint.clone(),
entry_2_to_3_and_1_to_mint.clone(),
entry_conflict_itself.clone()
entry_1_to_mint,
entry_2_to_3_and_1_to_mint,
entry_conflict_itself,
],
false,
None,
@ -2199,21 +2199,18 @@ pub mod tests {
// Transfer lamports to each other
let entry = next_entry(&bank.last_blockhash(), 1, tx_vector);
assert_eq!(process_entries(&bank, &vec![entry], true, None), Ok(()));
assert_eq!(process_entries(&bank, &[entry], true, None), Ok(()));
bank.squash();
// Even number keypair should have balance of 2 * initial_lamports and
// odd number keypair should have balance of 0, which proves
// that even in case of random order of execution, overall state remains
// consistent.
for i in 0..num_accounts {
for (i, keypair) in keypairs.iter().enumerate() {
if i % 2 == 0 {
assert_eq!(
bank.get_balance(&keypairs[i].pubkey()),
2 * initial_lamports
);
assert_eq!(bank.get_balance(&keypair.pubkey()), 2 * initial_lamports);
} else {
assert_eq!(bank.get_balance(&keypairs[i].pubkey()), 0);
assert_eq!(bank.get_balance(&keypair.pubkey()), 0);
}
}
}
@ -2260,12 +2257,7 @@ pub mod tests {
system_transaction::transfer(&keypair1, &keypair4.pubkey(), 1, bank.last_blockhash());
let entry_2 = next_entry(&tick.hash, 1, vec![tx]);
assert_eq!(
process_entries(
&bank,
&[entry_1.clone(), tick.clone(), entry_2.clone()],
true,
None
),
process_entries(&bank, &[entry_1, tick, entry_2.clone()], true, None),
Ok(())
);
assert_eq!(bank.get_balance(&keypair3.pubkey()), 1);
@ -2539,7 +2531,9 @@ pub mod tests {
.expect("process ticks failed");
if i % 16 == 0 {
root.map(|old_root| old_root.squash());
if let Some(old_root) = root {
old_root.squash();
}
root = Some(bank.clone());
}
i += 1;
@ -2584,7 +2578,7 @@ pub mod tests {
account_paths: Vec<PathBuf>,
) -> EpochSchedule {
let bank = Bank::new_with_paths(&genesis_config, account_paths, &[]);
bank.epoch_schedule().clone()
*bank.epoch_schedule()
}
fn frozen_bank_slots(bank_forks: &BankForks) -> Vec<Slot> {

8
ledger/src/entry.rs
View File

@ -542,7 +542,7 @@ mod tests {
let tx1 = system_transaction::transfer(&keypair, &keypair.pubkey(), 1, zero);
// Verify entry with 2 transctions
let mut e0 = vec![Entry::new(&zero, 0, vec![tx0.clone(), tx1.clone()])];
let mut e0 = vec![Entry::new(&zero, 0, vec![tx0, tx1])];
assert!(e0.verify(&zero));
// Clear signature of the first transaction, see that it does not verify
@ -598,7 +598,7 @@ mod tests {
let tx0 = create_sample_timestamp(&keypair, zero);
let entry0 = next_entry(&zero, 1, vec![tx0.clone()]);
assert_eq!(entry0.num_hashes, 1);
assert_eq!(entry0.hash, next_hash(&zero, 1, &vec![tx0]));
assert_eq!(entry0.hash, next_hash(&zero, 1, &[tx0]));
}
#[test]
@ -707,7 +707,7 @@ mod tests {
assert!(tx_and_no_hash_tick.verify_tick_hash_count(&mut tick_hash_count, 0));
assert_eq!(tick_hash_count, 0);
let single_tick = vec![full_tick_entry.clone()];
let single_tick = vec![full_tick_entry];
assert!(single_tick.verify_tick_hash_count(&mut tick_hash_count, hashes_per_tick));
assert_eq!(tick_hash_count, 0);
assert!(!single_tick.verify_tick_hash_count(&mut tick_hash_count, hashes_per_tick - 1));
@ -718,7 +718,7 @@ mod tests {
assert!(ticks_and_txs.verify_tick_hash_count(&mut tick_hash_count, hashes_per_tick));
assert_eq!(tick_hash_count, 0);
let partial_tick = vec![partial_tick_entry.clone()];
let partial_tick = vec![partial_tick_entry];
assert!(!partial_tick.verify_tick_hash_count(&mut tick_hash_count, hashes_per_tick));
assert_eq!(tick_hash_count, hashes_per_tick - 1);
tick_hash_count = 0;

18
ledger/src/hardened_unpack.rs
View File

@ -383,7 +383,7 @@ mod tests {
let mut archive = Builder::new(Vec::new());
archive.append(&header, data).unwrap();
let result = finalize_and_unpack_snapshot(archive);
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message.to_string() == *"invalid path found: \"foo/../../../dangerous\"");
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message == "invalid path found: \"foo/../../../dangerous\"");
}
fn with_archive_unpack_snapshot_invalid_path(path: &str) -> Result<()> {
@ -406,7 +406,7 @@ mod tests {
archive.append(&header, data).unwrap();
with_finalize_and_unpack(archive, |unpacking_archive, path| {
for entry in unpacking_archive.entries()? {
if entry?.unpack_in(path)? == false {
if !entry?.unpack_in(path)? {
return Err(UnpackError::Archive("failed!".to_string()));
} else if !path.join(path).exists() {
return Err(UnpackError::Archive("not existing!".to_string()));
@ -427,7 +427,7 @@ mod tests {
with_archive_unpack_snapshot_invalid_path("/etc/passwd"),
Ok(())
);
assert_matches!(with_archive_unpack_snapshot_invalid_path("../../../dangerous"), Err(UnpackError::Archive(ref message)) if message.to_string() == "failed!");
assert_matches!(with_archive_unpack_snapshot_invalid_path("../../../dangerous"), Err(UnpackError::Archive(ref message)) if message == "failed!");
}
#[test]
@ -442,14 +442,14 @@ mod tests {
let mut archive = Builder::new(Vec::new());
archive.append(&header, data).unwrap();
let result = finalize_and_unpack_snapshot(archive);
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message.to_string() == *"extra entry found: \"foo\"");
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message == "extra entry found: \"foo\"");
}
#[test]
fn test_archive_unpack_snapshot_too_large() {
let mut header = Header::new_gnu();
header.set_path("version").unwrap();
header.set_size(1 * 1024 * 1024 * 1024 * 1024 * 1024);
header.set_size(1024 * 1024 * 1024 * 1024 * 1024);
header.set_cksum();
let data: &[u8] = &[1, 2, 3, 4];
@ -457,13 +457,13 @@ mod tests {
let mut archive = Builder::new(Vec::new());
archive.append(&header, data).unwrap();
let result = finalize_and_unpack_snapshot(archive);
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message.to_string() == format!("too large archive: 1125899906842624 than limit: {}", MAX_SNAPSHOT_ARCHIVE_UNPACKED_SIZE));
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message == &format!("too large archive: 1125899906842624 than limit: {}", MAX_SNAPSHOT_ARCHIVE_UNPACKED_SIZE));
}
#[test]
fn test_archive_unpack_snapshot_bad_unpack() {
let result = check_unpack_result(false, "abc".to_string());
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message.to_string() == *"failed to unpack: \"abc\"");
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message == "failed to unpack: \"abc\"");
}
#[test]
@ -473,7 +473,7 @@ mod tests {
let result =
checked_total_size_sum(u64::max_value() - 2, 2, MAX_SNAPSHOT_ARCHIVE_UNPACKED_SIZE);
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message.to_string() == format!("too large archive: 18446744073709551615 than limit: {}", MAX_SNAPSHOT_ARCHIVE_UNPACKED_SIZE));
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message == &format!("too large archive: 18446744073709551615 than limit: {}", MAX_SNAPSHOT_ARCHIVE_UNPACKED_SIZE));
}
#[test]
@ -483,6 +483,6 @@ mod tests {
let result =
checked_total_count_increment(999_999_999_999, MAX_SNAPSHOT_ARCHIVE_UNPACKED_COUNT);
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message.to_string() == *"too many files in snapshot: 1000000000000");
assert_matches!(result, Err(UnpackError::Archive(ref message)) if message == "too many files in snapshot: 1000000000000");
}
}

4
ledger/src/leader_schedule_cache.rs
View File

@ -400,11 +400,11 @@ mod tests {
);
assert_eq!(
cache.next_leader_slot(&pubkey, 0, &bank, None, std::u64::MAX),
Some((1, 863999))
Some((1, 863_999))
);
assert_eq!(
cache.next_leader_slot(&pubkey, 1, &bank, None, std::u64::MAX),
Some((2, 863999))
Some((2, 863_999))
);
assert_eq!(
cache.next_leader_slot(

3
ledger/src/next_slots_iterator.rs
View File

@ -91,21 +91,18 @@ mod tests {
// Trying to get an iterator on any slot on the root fork should succeed
let result: HashSet<_> = NextSlotsIterator::new(0, &blockstore)
.into_iter()
.map(|(slot, _)| slot)
.collect();
let expected = vec![0, 1, 2, 3, 4].into_iter().collect();
assert_eq!(result, expected);
let result: HashSet<_> = NextSlotsIterator::new(2, &blockstore)
.into_iter()
.map(|(slot, _)| slot)
.collect();
let expected = vec![2, 3].into_iter().collect();
assert_eq!(result, expected);
let result: HashSet<_> = NextSlotsIterator::new(4, &blockstore)
.into_iter()
.map(|(slot, _)| slot)
.collect();
let expected = vec![4].into_iter().collect();

4
ledger/src/rooted_slot_iterator.rs
View File

@ -139,7 +139,6 @@ mod tests {
// Trying to get an iterator on any slot on the root fork should succeed
let result: Vec<_> = RootedSlotIterator::new(3, &blockstore)
.unwrap()
.into_iter()
.map(|(slot, _)| slot)
.collect();
let expected = vec![3];
@ -147,7 +146,6 @@ mod tests {
let result: Vec<_> = RootedSlotIterator::new(0, &blockstore)
.unwrap()
.into_iter()
.map(|(slot, _)| slot)
.collect();
let expected = vec![0, 1, 2, 3];
@ -207,7 +205,6 @@ mod tests {
// should not return a SlotMeta
let result: Vec<_> = RootedSlotIterator::new(3, &blockstore)
.unwrap()
.into_iter()
.map(|(slot, meta)| (slot, meta.is_some()))
.collect();
let expected = vec![(3, true), (10, false)];
@ -221,7 +218,6 @@ mod tests {
let result: Vec<_> = RootedSlotIterator::new(0, &blockstore)
.unwrap()
.into_iter()
.map(|(slot, meta)| (slot, meta.is_some()))
.collect();
let expected = vec![

24
ledger/src/shred.rs
View File

@ -961,7 +961,7 @@ pub mod tests {
#[test]
fn test_data_shredder() {
let keypair = Arc::new(Keypair::new());
let slot = 0x123456789abcdef0;
let slot = 0x1234_5678_9abc_def0;
// Test that parent cannot be > current slot
assert_matches!(
@ -1057,7 +1057,7 @@ pub mod tests {
let slot = 1;
let parent_slot = 0;
let shredder = Shredder::new(slot, parent_slot, 0.0, keypair.clone(), 0, 0)
let shredder = Shredder::new(slot, parent_slot, 0.0, keypair, 0, 0)
.expect("Failed in creating shredder");
let entries: Vec<_> = (0..5)
@ -1083,7 +1083,7 @@ pub mod tests {
let slot = 1;
let parent_slot = 0;
let shredder = Shredder::new(slot, parent_slot, 0.0, keypair.clone(), 5, 0)
let shredder = Shredder::new(slot, parent_slot, 0.0, keypair, 5, 0)
.expect("Failed in creating shredder");
let entries: Vec<_> = (0..5)
@ -1113,7 +1113,7 @@ pub mod tests {
let slot = 1;
let parent_slot = 0;
let shredder = Shredder::new(slot, parent_slot, 0.0, keypair.clone(), u8::max_value(), 0)
let shredder = Shredder::new(slot, parent_slot, 0.0, keypair, u8::max_value(), 0)
.expect("Failed in creating shredder");
let entries: Vec<_> = (0..5)
@ -1147,14 +1147,14 @@ pub mod tests {
fn test_data_and_code_shredder() {
let keypair = Arc::new(Keypair::new());
let slot = 0x123456789abcdef0;
let slot = 0x1234_5678_9abc_def0;
// Test that FEC rate cannot be > 1.0
assert_matches!(
Shredder::new(slot, slot - 5, 1.001, keypair.clone(), 0, 0),
Err(ShredError::InvalidFecRate(_))
);
let shredder = Shredder::new(0x123456789abcdef0, slot - 5, 1.0, keypair.clone(), 0, 0)
let shredder = Shredder::new(0x1234_5678_9abc_def0, slot - 5, 1.0, keypair.clone(), 0, 0)
.expect("Failed in creating shredder");
// Create enough entries to make > 1 shred
@ -1192,7 +1192,7 @@ pub mod tests {
#[test]
fn test_recovery_and_reassembly() {
let keypair = Arc::new(Keypair::new());
let slot = 0x123456789abcdef0;
let slot = 0x1234_5678_9abc_def0;
let shredder = Shredder::new(slot, slot - 5, 1.0, keypair.clone(), 0, 0)
.expect("Failed in creating shredder");
@ -1554,12 +1554,10 @@ pub mod tests {
assert!(data_shreds.len() > MAX_DATA_SHREDS_PER_FEC_BLOCK as usize);
(1..=MAX_DATA_SHREDS_PER_FEC_BLOCK as usize)
.into_iter()
.for_each(|count| {
let coding_shreds = shredder.data_shreds_to_coding_shreds(&data_shreds[..count]);
assert_eq!(coding_shreds.len(), count);
});
(1..=MAX_DATA_SHREDS_PER_FEC_BLOCK as usize).for_each(|count| {
let coding_shreds = shredder.data_shreds_to_coding_shreds(&data_shreds[..count]);
assert_eq!(coding_shreds.len(), count);
});
let coding_shreds = shredder.data_shreds_to_coding_shreds(
&data_shreds[..MAX_DATA_SHREDS_PER_FEC_BLOCK as usize + 1],

10
ledger/src/sigverify_shreds.rs
View File

@ -452,7 +452,7 @@ pub mod tests {
fn test_sigverify_shred_cpu() {
solana_logger::setup();
let mut packet = Packet::default();
let slot = 0xdeadc0de;
let slot = 0xdead_c0de;
let mut shred = Shred::new_from_data(
slot,
0xc0de,
@ -495,7 +495,7 @@ pub mod tests {
fn test_sigverify_shreds_cpu() {
solana_logger::setup();
let mut batch = [Packets::default()];
let slot = 0xdeadc0de;
let slot = 0xdead_c0de;
let mut shred = Shred::new_from_data(
slot,
0xc0de,
@ -547,7 +547,7 @@ pub mod tests {
let recycler_cache = RecyclerCache::default();
let mut batch = [Packets::default()];
let slot = 0xdeadc0de;
let slot = 0xdead_c0de;
let mut shred = Shred::new_from_data(
slot,
0xc0de,
@ -610,7 +610,7 @@ pub mod tests {
let mut packets = Packets::default();
let num_packets = 32;
let num_batches = 100;
let slot = 0xdeadc0de;
let slot = 0xdead_c0de;
packets.packets.resize(num_packets, Packet::default());
for (i, p) in packets.packets.iter_mut().enumerate() {
let shred = Shred::new_from_data(
@ -654,7 +654,7 @@ pub mod tests {
solana_logger::setup();
let mut batch = [Packets::default()];
let slot = 0xdeadc0de;
let slot = 0xdead_c0de;
let keypair = Keypair::new();
let shred = Shred::new_from_data(
slot,

2
ledger/tests/shred.rs
View File

@ -10,7 +10,7 @@ use std::sync::Arc;
#[test]
fn test_multi_fec_block_coding() {
let keypair = Arc::new(Keypair::new());
let slot = 0x123456789abcdef0;
let slot = 0x1234_5678_9abc_def0;
let shredder = Shredder::new(slot, slot - 5, 1.0, keypair.clone(), 0, 0)
.expect("Failed in creating shredder");