bitcoinleveldb-coding 0.1.19

Low-level LevelDB-compatible binary coding primitives for bitcoin-rs: fixed-width little-endian, varint, and length-prefixed encoding/decoding over raw pointers, Strings, and Slices.
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

// ---------------- [ File: bitcoinleveldb-coding/tests/encode_varint_roundtrip.rs ]
use bitcoinleveldb_coding::*;
use bitcoin_imports::*;

#[traced_test]
fn encode_varint32_roundtrip_and_length() {
    info!("encode_varint32_roundtrip_and_length: start");
    let values: [u32; 7] = [
        0,
        1,
        127,
        128,
        255,
        300,
        u32::MAX,
    ];

    for &v in &values {
        let mut buf = [0u8; 5];
        let start = buf.as_mut_ptr();
        let end = unsafe { encode_varint32(start, v) };
        let encoded_len = unsafe { end.offset_from(start) as usize };
        assert!(
            (1..=5).contains(&encoded_len),
            "encode_varint32_roundtrip_and_length: invalid length {} for {}",
            encoded_len,
            v
        );
        assert_eq!(
            varint_length(v as u64) as usize,
            encoded_len,
            "encode_varint32_roundtrip_and_length: length mismatch for {}",
            v
        );

        let mut decoded: u32 = 0;
        let limit = unsafe { start.add(encoded_len) } as *const u8;
        let p = unsafe {
            get_varint_32ptr(start as *const u8, limit, &mut decoded)
        };
        assert!(
            !p.is_null(),
            "encode_varint32_roundtrip_and_length: null pointer for {}",
            v
        );
        assert_eq!(
            limit, p,
            "encode_varint32_roundtrip_and_length: pointer mismatch for {}",
            v
        );
        assert_eq!(
            v, decoded,
            "encode_varint32_roundtrip_and_length: decode mismatch for {}",
            v
        );
    }

    info!("encode_varint32_roundtrip_and_length: success");
}

#[traced_test]
fn encode_varint64_roundtrip_and_length() {
    info!("encode_varint64_roundtrip_and_length: start");
    let values: [u64; 8] = [
        0,
        1,
        127,
        128,
        255,
        300,
        (1u64 << 63) - 1,
        u64::MAX,
    ];

    for &v in &values {
        let mut buf = [0u8; 10];
        let start = buf.as_mut_ptr();
        let end = unsafe { encode_varint64(start, v) };
        let encoded_len = unsafe { end.offset_from(start) as usize };
        assert!(
            (1..=10).contains(&encoded_len),
            "encode_varint64_roundtrip_and_length: invalid length {} for {}",
            encoded_len,
            v
        );
        assert_eq!(
            varint_length(v) as usize,
            encoded_len,
            "encode_varint64_roundtrip_and_length: length mismatch for {}",
            v
        );

        let mut decoded: u64 = 0;
        let limit = unsafe { start.add(encoded_len) } as *const u8;
        let p = unsafe {
            get_varint_64ptr(start as *const u8, limit, &mut decoded)
        };
        assert!(
            !p.is_null(),
            "encode_varint64_roundtrip_and_length: null pointer for {}",
            v
        );
        assert_eq!(
            limit, p,
            "encode_varint64_roundtrip_and_length: pointer mismatch for {}",
            v
        );
        assert_eq!(
            v, decoded,
            "encode_varint64_roundtrip_and_length: decode mismatch for {}",
            v
        );
    }

    info!("encode_varint64_roundtrip_and_length: success");
}