octo
/
Zebra
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Split TEST_BLOCKS into mainnet and testnet 

And add some basic tests to make sure:
* the heights are correct
* the lists aren't truncated or empty
This commit is contained in:
teor 2020-09-29 17:01:07 +10:00 committed by Deirdre Connolly
parent 15c5365ca7
commit a35f36dd0b
2 changed files with 126 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
zebra-chain/src/block/tests/vectors.rs
View File

@ -90,6 +90,33 @@ fn block_test_vectors_unique() {
); );
} }
#[test]
fn block_test_vectors_height_mainnet() {
block_test_vectors_height(Network::Mainnet);
}
#[test]
fn block_test_vectors_height_testnet() {
block_test_vectors_height(Network::Testnet);
}
fn block_test_vectors_height(network: Network) {
let block_iter = match network {
Network::Mainnet => zebra_test::vectors::MAINNET_BLOCKS.iter(),
Network::Testnet => zebra_test::vectors::TESTNET_BLOCKS.iter(),
};
for (&height, block) in block_iter {
let block = block
.zcash_deserialize_into::<Block>()
.expect("block is structurally valid");
assert_eq!(
block.coinbase_height().expect("block height is valid").0,
height
);
}
}
#[test] #[test]
fn block_limits_multi_tx() { fn block_limits_multi_tx() {
// Test multiple small transactions to fill a block max size // Test multiple small transactions to fill a block max size

172
zebra-test/src/vectors/block.rs
View File

@ -3,80 +3,95 @@
use hex::FromHex; use hex::FromHex;
use lazy_static::lazy_static; use lazy_static::lazy_static;
lazy_static! { use std::collections::BTreeMap;
// Update this list of test blocks when you add a new block test vector to use std::iter::FromIterator;
// this file
pub static ref TEST_BLOCKS: Vec<&'static [u8]> = vec![
// Mainnet
// Genesis
&BLOCK_MAINNET_GENESIS_BYTES,
// BeforeOverwinter
&BLOCK_MAINNET_1_BYTES,
&BLOCK_MAINNET_2_BYTES,
&BLOCK_MAINNET_3_BYTES,
&BLOCK_MAINNET_4_BYTES,
&BLOCK_MAINNET_5_BYTES,
&BLOCK_MAINNET_6_BYTES,
&BLOCK_MAINNET_7_BYTES,
&BLOCK_MAINNET_8_BYTES,
&BLOCK_MAINNET_9_BYTES,
&BLOCK_MAINNET_10_BYTES,
&BLOCK_MAINNET_347499_BYTES,
// Overwinter
&BLOCK_MAINNET_347500_BYTES,
&BLOCK_MAINNET_347501_BYTES,
&BLOCK_MAINNET_415000_BYTES,
&BLOCK_MAINNET_419199_BYTES,
// Sapling
&BLOCK_MAINNET_419200_BYTES,
&BLOCK_MAINNET_419201_BYTES,
&BLOCK_MAINNET_434873_BYTES,
&BLOCK_MAINNET_653599_BYTES,
// Blossom
&BLOCK_MAINNET_653600_BYTES,
&BLOCK_MAINNET_653601_BYTES,
&BLOCK_MAINNET_902999_BYTES,
// Heartwood
&BLOCK_MAINNET_903000_BYTES,
&BLOCK_MAINNET_903001_BYTES,
// TODO: Canopy
// Testnet lazy_static! {
// Genesis
&BLOCK_TESTNET_GENESIS_BYTES, /// All block test vectors
// BeforeOverwinter pub static ref TEST_BLOCKS: Vec<&'static [u8]> = MAINNET_BLOCKS.iter().chain(TESTNET_BLOCKS.iter()).map(|(_height, block)| *block).collect();
&BLOCK_TESTNET_1_BYTES,
&BLOCK_TESTNET_2_BYTES, // Update these lists of blocks when you add new block test vectors to
&BLOCK_TESTNET_3_BYTES, // this file
&BLOCK_TESTNET_4_BYTES,
&BLOCK_TESTNET_5_BYTES, /// Mainnet blocks, indexed by height
&BLOCK_TESTNET_6_BYTES, pub static ref MAINNET_BLOCKS: BTreeMap<u32, &'static [u8]> = BTreeMap::from_iter(
&BLOCK_TESTNET_7_BYTES, [
&BLOCK_TESTNET_8_BYTES, // Genesis
&BLOCK_TESTNET_9_BYTES, (0, BLOCK_MAINNET_GENESIS_BYTES.as_ref()),
&BLOCK_TESTNET_10_BYTES, // BeforeOverwinter
&BLOCK_TESTNET_207499_BYTES, (1, BLOCK_MAINNET_1_BYTES.as_ref()),
// Overwinter (2, BLOCK_MAINNET_2_BYTES.as_ref()),
&BLOCK_TESTNET_207500_BYTES, (3, BLOCK_MAINNET_3_BYTES.as_ref()),
&BLOCK_TESTNET_207501_BYTES, (4, BLOCK_MAINNET_4_BYTES.as_ref()),
&BLOCK_TESTNET_279999_BYTES, (5, BLOCK_MAINNET_5_BYTES.as_ref()),
// Sapling (6, BLOCK_MAINNET_6_BYTES.as_ref()),
&BLOCK_TESTNET_280000_BYTES, (7, BLOCK_MAINNET_7_BYTES.as_ref()),
&BLOCK_TESTNET_280001_BYTES, (8, BLOCK_MAINNET_8_BYTES.as_ref()),
&BLOCK_TESTNET_583999_BYTES, (9, BLOCK_MAINNET_9_BYTES.as_ref()),
// Blossom (10, BLOCK_MAINNET_10_BYTES.as_ref()),
&BLOCK_TESTNET_584000_BYTES, (347_499, BLOCK_MAINNET_347499_BYTES.as_ref()),
&BLOCK_TESTNET_584001_BYTES, // Overwinter
&BLOCK_TESTNET_903799_BYTES, (347_500, BLOCK_MAINNET_347500_BYTES.as_ref()),
// Heartwood (347_501, BLOCK_MAINNET_347501_BYTES.as_ref()),
&BLOCK_TESTNET_903800_BYTES, (415_000, BLOCK_MAINNET_415000_BYTES.as_ref()),
&BLOCK_TESTNET_903801_BYTES, (419_199, BLOCK_MAINNET_419199_BYTES.as_ref()),
&BLOCK_TESTNET_1028499_BYTES, // Sapling
// Canopy (419_200, BLOCK_MAINNET_419200_BYTES.as_ref()),
&BLOCK_TESTNET_1028500_BYTES, (419_201, BLOCK_MAINNET_419201_BYTES.as_ref()),
&BLOCK_TESTNET_1028501_BYTES, (434_873, BLOCK_MAINNET_434873_BYTES.as_ref()),
&BLOCK_TESTNET_1095000_BYTES, (653_599, BLOCK_MAINNET_653599_BYTES.as_ref()),
]; // Blossom
(653_600, BLOCK_MAINNET_653600_BYTES.as_ref()),
(653_601, BLOCK_MAINNET_653601_BYTES.as_ref()),
(902_999, BLOCK_MAINNET_902999_BYTES.as_ref()),
// Heartwood
(903_000, BLOCK_MAINNET_903000_BYTES.as_ref()),
(903_001, BLOCK_MAINNET_903001_BYTES.as_ref()),
// TODO: Canopy and First Halving, see #1099
].iter().cloned()
);
/// Testnet blocks, indexed by height
pub static ref TESTNET_BLOCKS: BTreeMap<u32, &'static [u8]> = BTreeMap::from_iter(
[
// Genesis
(0, BLOCK_TESTNET_GENESIS_BYTES.as_ref()),
// BeforeOverwinter
(1, BLOCK_TESTNET_1_BYTES.as_ref()),
(2, BLOCK_TESTNET_2_BYTES.as_ref()),
(3, BLOCK_TESTNET_3_BYTES.as_ref()),
(4, BLOCK_TESTNET_4_BYTES.as_ref()),
(5, BLOCK_TESTNET_5_BYTES.as_ref()),
(6, BLOCK_TESTNET_6_BYTES.as_ref()),
(7, BLOCK_TESTNET_7_BYTES.as_ref()),
(8, BLOCK_TESTNET_8_BYTES.as_ref()),
(9, BLOCK_TESTNET_9_BYTES.as_ref()),
(10, BLOCK_TESTNET_10_BYTES.as_ref()),
(207_499, BLOCK_TESTNET_207499_BYTES.as_ref()),
// Overwinter
(207_500, BLOCK_TESTNET_207500_BYTES.as_ref()),
(207_501, BLOCK_TESTNET_207501_BYTES.as_ref()),
(279_999, BLOCK_TESTNET_279999_BYTES.as_ref()),
// Sapling
(280_000, BLOCK_TESTNET_280000_BYTES.as_ref()),
(280_001, BLOCK_TESTNET_280001_BYTES.as_ref()),
(583_999, BLOCK_TESTNET_583999_BYTES.as_ref()),
// Blossom
(584_000, BLOCK_TESTNET_584000_BYTES.as_ref()),
(584_001, BLOCK_TESTNET_584001_BYTES.as_ref()),
(903_799, BLOCK_TESTNET_903799_BYTES.as_ref()),
// Heartwood
(903_800, BLOCK_TESTNET_903800_BYTES.as_ref()),
(903_801, BLOCK_TESTNET_903801_BYTES.as_ref()),
(1_028_499, BLOCK_TESTNET_1028499_BYTES.as_ref()),
// Canopy
(1_028_500, BLOCK_TESTNET_1028500_BYTES.as_ref()),
(1_028_501, BLOCK_TESTNET_1028501_BYTES.as_ref()),
(1_095_000, BLOCK_TESTNET_1095000_BYTES.as_ref()),
// TODO: First Halving, see #1104
].iter().cloned()
);
// Mainnet // Mainnet
@ -318,4 +333,15 @@ mod test {
"block test vectors must be unique" "block test vectors must be unique"
); );
} }
/// Make sure we use all the test vectors in the lists.
///
/// We're using lazy_static! and combinators, so it would be easy to make this mistake.
#[test]
fn block_test_vectors_count() {
assert!(
TEST_BLOCKS.len() > 50,
"there should be a reasonable number of block test vectors"
);
}
} }