bitcoin-serialize 0.1.19

tools for serialization
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// ---------------- [ File: bitcoin-serialize/src/write_with_size_computer.rs ]
crate::ix!();

#[inline]
pub fn write_compact_size_with_size_computer(s: &mut SizeComputer, n_size: u64) {
    let sz = get_size_of_compact_size(n_size);
    trace!(bytes = sz, "write_compact_size_with_size_computer");
    s.seek(sz as usize);
}

#[inline]
pub fn write_var_int_with_size_computer<I>(s: &mut SizeComputer, n: I)
where
    I: Into<u128> + Copy,
    (): ModeConstraint<{ VarIntMode::Default }, I>,
{
    let sz = get_size_of_var_int::<I, { VarIntMode::Default }>(n);
    trace!(bytes = sz, "write_var_int_with_size_computer");
    s.seek(sz as usize);
}


#[cfg(test)]
mod size_computer_helper_tests {
    use super::*;

    #[traced_test]
    fn write_compact_size_with_sc_counts_correctly() {
        for &len in &[0u64, 252, 253, 65_536, 4_000_000_000] {
            let mut sc = SizeComputer::new(0);
            write_compact_size_with_size_computer(&mut sc, len);

            let expect = get_size_of_compact_size(len) as usize;
            assert_eq!(sc.size(), expect, "len={len}");
        }
    }

    #[traced_test]
    fn write_var_int_with_sc_counts_correctly() {
        for &n in &[0u64, 1, 0x7F, 0x80, 0x3FFF, 0x4000, u32::MAX as u64] {
            let mut sc = SizeComputer::new(0);
            write_var_int_with_size_computer(&mut sc, n);

            let expect =
                get_size_of_var_int::<u64, { VarIntMode::Default }>(n) as usize;
            assert_eq!(sc.size(), expect, "n={n}");
        }
    }

    /// Cross‑check the helpers against *real* serialization.
    #[traced_test]
    fn helpers_match_actual_byte_stream() {
        let value = 123_456u64;

        // ── Real bytes written ──
        let mut cur = std::io::Cursor::new(Vec::<u8>::new());
        crate::compact_size::write_compact_size(&mut cur, value);
        write_var_int::<_, u64, { VarIntMode::Default }>(&mut cur, value);
        let actual_bytes = cur.into_inner().len();

        // ── Simulated bytes written ──
        let mut sc = SizeComputer::new(0);
        write_compact_size_with_size_computer(&mut sc, value);
        write_var_int_with_size_computer(&mut sc, value);

        assert_eq!(sc.size(), actual_bytes);
    }
}