zcash_address/
test_vectors.rs

1/// Export test vectors for reuse by implementers of address parsing libraries.
2#[cfg(feature = "test-dependencies")]
3pub use crate::unified::address::test_vectors::TEST_VECTORS as UNIFIED;
4
5#[cfg(test)]
6use {
7    crate::{
8        unified::{
9            self,
10            address::{test_vectors::TEST_VECTORS, Receiver},
11        },
12        ToAddress, ZcashAddress,
13    },
14    alloc::string::ToString,
15    core::iter,
16    zcash_protocol::consensus::NetworkType,
17};
18
19#[test]
20fn unified() {
21    for tv in TEST_VECTORS {
22        // Double-check test vectors match requirements:
23        // - Only one of P2PKH and P2SH.
24        assert!(tv.p2pkh_bytes.is_none() || tv.p2sh_bytes.is_none());
25        // - At least one shielded receiver.
26        assert!(tv.sapling_raw_addr.is_some() || tv.orchard_raw_addr.is_some());
27
28        let unknown_tc = tv.unknown_typecode;
29        let unknown_bytes = tv.unknown_bytes;
30        let receivers = iter::empty()
31            .chain(tv.p2pkh_bytes.map(Receiver::P2pkh))
32            .chain(tv.p2sh_bytes.map(Receiver::P2sh))
33            .chain(tv.sapling_raw_addr.map(Receiver::Sapling))
34            .chain(tv.orchard_raw_addr.map(Receiver::Orchard))
35            .chain(unknown_tc.and_then(|typecode| {
36                unknown_bytes.map(move |data| Receiver::Unknown {
37                    typecode,
38                    data: data.to_vec(),
39                })
40            }))
41            .collect();
42
43        let expected_addr =
44            ZcashAddress::from_unified(NetworkType::Main, unified::Address(receivers));
45
46        // Test parsing
47        let addr: ZcashAddress = tv.unified_addr.parse().unwrap();
48        assert_eq!(addr, expected_addr);
49
50        // Test serialization
51        assert_eq!(expected_addr.to_string(), tv.unified_addr.to_string());
52    }
53}