gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-03 00:31:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix test compilations

Browse Source
This commit is contained in:
Pawan Dhananjay
2024-09-04 12:47:36 -07:00
parent 52bb581e07
commit d37733b846
6 changed files with 86 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
View File

@@ -837,7 +837,8 @@ mod test {
info!(log, "done printing kzg commitments");
let gossip_verified_blobs = if let Some((kzg_proofs, blobs)) = maybe_blobs {
let sidecars = BlobSidecar::build_sidecars(blobs, &block, kzg_proofs).unwrap();
let sidecars =
BlobSidecar::build_sidecars(blobs, &block, kzg_proofs, &chain.spec).unwrap();
Vec::from(sidecars)
.into_iter()
.map(|sidecar| {
@@ -1152,7 +1153,7 @@ mod pending_components_tests {
use super::*;
use crate::block_verification_types::BlockImportData;
use crate::eth1_finalization_cache::Eth1FinalizationData;
use crate::test_utils::{generate_rand_block_and_blobs, NumBlobs};
use crate::test_utils::{generate_rand_block_and_blobs, test_spec, NumBlobs};
use crate::PayloadVerificationOutcome;
use fork_choice::PayloadVerificationStatus;
use kzg::KzgCommitment;
@@ -1168,15 +1169,19 @@ mod pending_components_tests {
type Setup<E> = (
SignedBeaconBlock<E>,
FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
RuntimeFixedList<Option<Arc<BlobSidecar<E>>>>,
RuntimeFixedList<Option<Arc<BlobSidecar<E>>>>,
usize,
);
pub fn pre_setup() -> Setup<E> {
let mut rng = StdRng::seed_from_u64(0xDEADBEEF0BAD5EEDu64);
let spec = test_spec::<E>();
let (block, blobs_vec) =
generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Random, &mut rng);
let mut blobs: FixedVector<_, <E as EthSpec>::MaxBlobsPerBlock> = FixedVector::default();
let max_len = spec.max_blobs_per_block(block.epoch()) as usize;
let mut blobs: RuntimeFixedList<Option<Arc<BlobSidecar<E>>>> =
RuntimeFixedList::default(max_len);
for blob in blobs_vec {
if let Some(b) = blobs.get_mut(blob.index as usize) {
@@ -1184,10 +1189,8 @@ mod pending_components_tests {
}
}
let mut invalid_blobs: FixedVector<
Option<Arc<BlobSidecar<E>>>,
<E as EthSpec>::MaxBlobsPerBlock,
> = FixedVector::default();
let mut invalid_blobs: RuntimeFixedList<Option<Arc<BlobSidecar<E>>>> =
RuntimeFixedList::default(max_len);
for (index, blob) in blobs.iter().enumerate() {
if let Some(invalid_blob) = blob {
let mut blob_copy = invalid_blob.as_ref().clone();
@@ -1196,21 +1199,21 @@ mod pending_components_tests {
}
}
(block, blobs, invalid_blobs)
(block, blobs, invalid_blobs, max_len)
}
type PendingComponentsSetup<E> = (
DietAvailabilityPendingExecutedBlock<E>,
FixedVector<Option<KzgVerifiedBlob<E>>, <E as EthSpec>::MaxBlobsPerBlock>,
FixedVector<Option<KzgVerifiedBlob<E>>, <E as EthSpec>::MaxBlobsPerBlock>,
RuntimeFixedList<Option<KzgVerifiedBlob<E>>>,
RuntimeFixedList<Option<KzgVerifiedBlob<E>>>,
);
pub fn setup_pending_components(
block: SignedBeaconBlock<E>,
valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
valid_blobs: RuntimeFixedList<Option<Arc<BlobSidecar<E>>>>,
invalid_blobs: RuntimeFixedList<Option<Arc<BlobSidecar<E>>>>,
) -> PendingComponentsSetup<E> {
let blobs = FixedVector::from(
let blobs = RuntimeFixedList::new(
valid_blobs
.iter()
.map(|blob_opt| {
@@ -1220,7 +1223,7 @@ mod pending_components_tests {
})
.collect::<Vec<_>>(),
);
let invalid_blobs = FixedVector::from(
let invalid_blobs = RuntimeFixedList::new(
invalid_blobs
.iter()
.map(|blob_opt| {
@@ -1252,10 +1255,10 @@ mod pending_components_tests {
(block.into(), blobs, invalid_blobs)
}
pub fn assert_cache_consistent(cache: PendingComponents<E>) {
pub fn assert_cache_consistent(cache: PendingComponents<E>, max_len: usize) {
if let Some(cached_block) = cache.get_cached_block() {
let cached_block_commitments = cached_block.get_commitments();
for index in 0..E::max_blobs_per_block() {
for index in 0..max_len {
let block_commitment = cached_block_commitments.get(index).copied();
let blob_commitment_opt = cache.get_cached_blobs().get(index).unwrap();
let blob_commitment = blob_commitment_opt.as_ref().map(|b| *b.get_commitment());
@@ -1274,40 +1277,40 @@ mod pending_components_tests {
#[test]
fn valid_block_invalid_blobs_valid_blobs() {
let (block_commitments, blobs, random_blobs) = pre_setup();
let (block_commitments, blobs, random_blobs, max_len) = pre_setup();
let (block_commitments, blobs, random_blobs) =
setup_pending_components(block_commitments, blobs, random_blobs);
let block_root = Hash256::zero();
let mut cache = <PendingComponents<E>>::empty(block_root);
let mut cache = <PendingComponents<E>>::empty(block_root, max_len);
cache.merge_block(block_commitments);
cache.merge_blobs(random_blobs);
cache.merge_blobs(blobs);
assert_cache_consistent(cache);
assert_cache_consistent(cache, max_len);
}
#[test]
fn invalid_blobs_block_valid_blobs() {
let (block_commitments, blobs, random_blobs) = pre_setup();
let (block_commitments, blobs, random_blobs, max_len) = pre_setup();
let (block_commitments, blobs, random_blobs) =
setup_pending_components(block_commitments, blobs, random_blobs);
let block_root = Hash256::zero();
let mut cache = <PendingComponents<E>>::empty(block_root);
let mut cache = <PendingComponents<E>>::empty(block_root, max_len);
cache.merge_blobs(random_blobs);
cache.merge_block(block_commitments);
cache.merge_blobs(blobs);
assert_cache_consistent(cache);
assert_cache_consistent(cache, max_len);
}
#[test]
fn invalid_blobs_valid_blobs_block() {
let (block_commitments, blobs, random_blobs) = pre_setup();
let (block_commitments, blobs, random_blobs, max_len) = pre_setup();
let (block_commitments, blobs, random_blobs) =
setup_pending_components(block_commitments, blobs, random_blobs);
let block_root = Hash256::zero();
let mut cache = <PendingComponents<E>>::empty(block_root);
let mut cache = <PendingComponents<E>>::empty(block_root, max_len);
cache.merge_blobs(random_blobs);
cache.merge_blobs(blobs);
cache.merge_block(block_commitments);
@@ -1317,46 +1320,46 @@ mod pending_components_tests {
#[test]
fn block_valid_blobs_invalid_blobs() {
let (block_commitments, blobs, random_blobs) = pre_setup();
let (block_commitments, blobs, random_blobs, max_len) = pre_setup();
let (block_commitments, blobs, random_blobs) =
setup_pending_components(block_commitments, blobs, random_blobs);
let block_root = Hash256::zero();
let mut cache = <PendingComponents<E>>::empty(block_root);
let mut cache = <PendingComponents<E>>::empty(block_root, max_len);
cache.merge_block(block_commitments);
cache.merge_blobs(blobs);
cache.merge_blobs(random_blobs);
assert_cache_consistent(cache);
assert_cache_consistent(cache, max_len);
}
#[test]
fn valid_blobs_block_invalid_blobs() {
let (block_commitments, blobs, random_blobs) = pre_setup();
let (block_commitments, blobs, random_blobs, max_len) = pre_setup();
let (block_commitments, blobs, random_blobs) =
setup_pending_components(block_commitments, blobs, random_blobs);
let block_root = Hash256::zero();
let mut cache = <PendingComponents<E>>::empty(block_root);
let mut cache = <PendingComponents<E>>::empty(block_root, max_len);
cache.merge_blobs(blobs);
cache.merge_block(block_commitments);
cache.merge_blobs(random_blobs);
assert_cache_consistent(cache);
assert_cache_consistent(cache, max_len);
}
#[test]
fn valid_blobs_invalid_blobs_block() {
let (block_commitments, blobs, random_blobs) = pre_setup();
let (block_commitments, blobs, random_blobs, max_len) = pre_setup();
let (block_commitments, blobs, random_blobs) =
setup_pending_components(block_commitments, blobs, random_blobs);
let block_root = Hash256::zero();
let mut cache = <PendingComponents<E>>::empty(block_root);
let mut cache = <PendingComponents<E>>::empty(block_root, max_len);
cache.merge_blobs(blobs);
cache.merge_blobs(random_blobs);
cache.merge_block(block_commitments);
assert_cache_consistent(cache);
assert_cache_consistent(cache, max_len);
}
}

6
beacon_node/beacon_chain/src/observed_data_sidecars.rs
View File

@@ -155,7 +155,7 @@ mod tests {
use crate::test_utils::test_spec;
use bls::Hash256;
use std::sync::Arc;
use types::MainnetEthSpec;
use types::{Epoch, MainnetEthSpec};
type E = MainnetEthSpec;
@@ -309,7 +309,7 @@ mod tests {
#[test]
fn simple_observations() {
let spec = test_spec::<E>();
let mut cache = ObservedDataSidecars::<BlobSidecar<E>>::new(spec);
let mut cache = ObservedDataSidecars::<BlobSidecar<E>>::new(spec.clone());
// Slot 0, index 0
let proposer_index_a = 420;
@@ -465,7 +465,7 @@ mod tests {
);
// Try adding an out of bounds index
let invalid_index = E::max_blobs_per_block() as u64;
let invalid_index = spec.max_blobs_per_block(Epoch::new(0));
let sidecar_d = get_blob_sidecar(0, proposer_index_a, invalid_index);
assert_eq!(
cache.observe_sidecar(&sidecar_d),

2
beacon_node/beacon_chain/tests/events.rs
View File

@@ -69,7 +69,7 @@ async fn blob_sidecar_event_on_process_rpc_blobs() {
index: 1,
..BlobSidecar::random_valid(&mut rng, kzg).unwrap()
});
let blobs = FixedBlobSidecarList::from(vec![Some(blob_1.clone()), Some(blob_2.clone())]);
let blobs = FixedBlobSidecarList::new(vec![Some(blob_1.clone()), Some(blob_2.clone())]);
let expected_sse_blobs = vec![
SseBlobSidecar::from_blob_sidecar(blob_1.as_ref()),
SseBlobSidecar::from_blob_sidecar(blob_2.as_ref()),

13
beacon_node/network/src/sync/block_lookups/tests.rs
View File

@@ -39,7 +39,7 @@ use types::{
test_utils::{SeedableRng, XorShiftRng},
BlobSidecar, ForkName, MinimalEthSpec as E, SignedBeaconBlock, Slot,
};
use types::{BeaconState, BeaconStateBase};
use types::{BeaconState, BeaconStateBase, ChainSpec};
use types::{DataColumnSidecar, Epoch};
type T = Witness<ManualSlotClock, CachingEth1Backend<E>, E, MemoryStore<E>, MemoryStore<E>>;
@@ -86,6 +86,7 @@ struct TestRig {
/// `rng` for generating test blocks and blobs.
rng: XorShiftRng,
fork_name: ForkName,
spec: ChainSpec,
log: Logger,
}
@@ -153,6 +154,8 @@ impl TestRig {
.network_globals
.set_sync_state(SyncState::Synced);
let spec = chain.spec.clone();
let rng = XorShiftRng::from_seed([42; 16]);
TestRig {
beacon_processor_rx,
@@ -174,6 +177,7 @@ impl TestRig {
harness,
fork_name,
log,
spec,
}
}
@@ -2048,8 +2052,8 @@ mod deneb_only {
use beacon_chain::{
block_verification_types::RpcBlock, data_availability_checker::AvailabilityCheckError,
};
use ssz_types::VariableList;
use std::collections::VecDeque;
use types::RuntimeVariableList;
struct DenebTester {
rig: TestRig,
@@ -2407,12 +2411,15 @@ mod deneb_only {
fn parent_block_unknown_parent(mut self) -> Self {
self.rig.log("parent_block_unknown_parent");
let block = self.unknown_parent_block.take().unwrap();
let max_len = self.rig.spec.max_blobs_per_block(block.epoch()) as usize;
// Now this block is the one we expect requests from
self.block = block.clone();
let block = RpcBlock::new(
Some(block.canonical_root()),
block,
self.unknown_parent_blobs.take().map(VariableList::from),
self.unknown_parent_blobs
.take()
.map(|vec| RuntimeVariableList::from_vec(vec, max_len)),
)
.unwrap();
self.rig.parent_block_processed(

42
beacon_node/network/src/sync/block_sidecar_coupling.rs
View File

@@ -252,12 +252,15 @@ mod tests {
#[test]
fn no_blobs_into_responses() {
let spec = test_spec::<E>();
let peer_id = PeerId::random();
let mut info = RangeBlockComponentsRequest::<E>::new(false, None, None, vec![peer_id]);
let mut rng = XorShiftRng::from_seed([42; 16]);
let blocks = (0..4)
.map(|_| generate_rand_block_and_blobs::<E>(ForkName::Base, NumBlobs::None, &mut rng).0)
.collect::<Vec<_>>();
let max_len = spec.max_blobs_per_block(blocks.first().unwrap().epoch()) as usize;
let mut info =
RangeBlockComponentsRequest::<E>::new(false, None, None, vec![peer_id], max_len);
// Send blocks and complete terminate response
for block in blocks {
@@ -272,8 +275,8 @@ mod tests {
#[test]
fn empty_blobs_into_responses() {
let spec = test_spec::<E>();
let peer_id = PeerId::random();
let mut info = RangeBlockComponentsRequest::<E>::new(true, None, None, vec![peer_id]);
let mut rng = XorShiftRng::from_seed([42; 16]);
let blocks = (0..4)
.map(|_| {
@@ -281,6 +284,9 @@ mod tests {
generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Number(3), &mut rng).0
})
.collect::<Vec<_>>();
let max_len = spec.max_blobs_per_block(blocks.first().unwrap().epoch()) as usize;
let mut info =
RangeBlockComponentsRequest::<E>::new(true, None, None, vec![peer_id], max_len);
// Send blocks and complete terminate response
for block in blocks {
@@ -301,12 +307,7 @@ mod tests {
fn rpc_block_with_custody_columns() {
let spec = test_spec::<E>();
let expects_custody_columns = vec![1, 2, 3, 4];
let mut info = RangeBlockComponentsRequest::<E>::new(
false,
Some(expects_custody_columns.clone()),
Some(expects_custody_columns.len()),
vec![PeerId::random()],
);
let mut rng = XorShiftRng::from_seed([42; 16]);
let blocks = (0..4)
.map(|_| {
@@ -318,7 +319,14 @@ mod tests {
)
})
.collect::<Vec<_>>();
let max_len = spec.max_blobs_per_block(blocks.first().unwrap().0.epoch()) as usize;
let mut info = RangeBlockComponentsRequest::<E>::new(
false,
Some(expects_custody_columns.clone()),
Some(expects_custody_columns.len()),
vec![PeerId::random()],
max_len,
);
// Send blocks and complete terminate response
for block in &blocks {
info.add_block_response(Some(block.0.clone().into()));
@@ -362,12 +370,7 @@ mod tests {
let spec = test_spec::<E>();
let expects_custody_columns = vec![1, 2, 3, 4];
let num_of_data_column_requests = 2;
let mut info = RangeBlockComponentsRequest::<E>::new(
false,
Some(expects_custody_columns.clone()),
Some(num_of_data_column_requests),
vec![PeerId::random()],
);
let mut rng = XorShiftRng::from_seed([42; 16]);
let blocks = (0..4)
.map(|_| {
@@ -379,7 +382,14 @@ mod tests {
)
})
.collect::<Vec<_>>();
let max_len = spec.max_blobs_per_block(blocks.first().unwrap().0.epoch()) as usize;
let mut info = RangeBlockComponentsRequest::<E>::new(
false,
Some(expects_custody_columns.clone()),
Some(num_of_data_column_requests),
vec![PeerId::random()],
max_len,
);
// Send blocks and complete terminate response
for block in &blocks {
info.add_block_response(Some(block.0.clone().into()));

18
consensus/types/src/runtime_var_list.rs
View File

@@ -292,6 +292,13 @@ impl<T: Clone + Default> RuntimeFixedList<T> {
self.vec
}
pub fn default(max_len: usize) -> Self {
Self {
vec: vec![T::default(); max_len],
len: max_len,
}
}
pub fn take(&mut self) -> Self {
let new = std::mem::take(&mut self.vec);
*self = Self::new(vec![T::default(); self.len]);
@@ -339,7 +346,6 @@ mod test {
use super::*;
use ssz::*;
use std::fmt::Debug;
use tree_hash::TreeHash;
#[test]
fn new() {
@@ -404,7 +410,7 @@ mod test {
}
fn round_trip<T: Encode + Decode + PartialEq + Debug>(item: RuntimeVariableList<T>) {
let max_len = item.max_len();
let max_len = item.max_len().unwrap();
let encoded = &item.as_ssz_bytes();
assert_eq!(item.ssz_bytes_len(), encoded.len());
assert_eq!(
@@ -418,12 +424,4 @@ mod test {
round_trip::<u16>(RuntimeVariableList::from_vec(vec![42; 8], 8));
round_trip::<u16>(RuntimeVariableList::from_vec(vec![0; 8], 8));
}
#[test]
fn test_empty_list_encoding() {
use ssz_types::{typenum::U16, VariableList};
let a: RuntimeVariableList<u64> = RuntimeVariableList::from_vec(vec![], 16);
dbg!(a.tree_hash_root());
}
}