bitcoin-bigint 0.1.19

Provides an efficient macro-based approach to define and manipulate arbitrary-precision unsigned integers, crucial for cryptographic operations on Bitcoin.
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

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

#[cfg(test)]
mod shr_assign_u32_64bit_exhaustive {
    use super::*;
    use tracing::{info, debug};

    #[traced_test]
    fn shr_assign_u32_correctness_against_native_u64() {
        info!("Begin correctness checks of `BaseUInt64 >>= u32` vs native u64.");

        for shift in 0..=70u32 {
            let test_inputs: [u64; 5] = [
                0,
                1,
                0xFFFFFFFFFFFFFFFF,
                0x00000000FFFFFFFF,
                0xFFFFFFFF00000000,
            ];

            for &val_u64 in &test_inputs {
                let mut bigval = BaseUInt64::from(val_u64);
                bigval >>= shift;
                let expected = if shift >= 64 { 0 } else { val_u64 >> shift };
                let got_u64 = bigval.low64();
                assert_eq!(
                    got_u64, expected,
                    "ShrAssign failed for val=0x{:016X}, shift={}",
                    val_u64, shift
                );
            }
        }

        info!("Finished systematic edge-case checks for `ShrAssign<u32>` on BaseUInt64.");
    }

    #[traced_test]
    fn shr_assign_u32_random_fuzz_64bit() {
        info!("Begin random-fuzz checks of `BaseUInt64 >>= u32`.");
        let mut rng = super::super::simple_lcg::SimpleLCG::new(0xACE0_1234_5678_90AB);

        for _ in 0..500 {
            let val_u64 = rng.next_u64();
            let mut bigval = BaseUInt64::from(val_u64);
            let shift = (rng.next_u64() % 129) as u32;

            let expected = if shift < 64 {
                val_u64 >> shift
            } else {
                0
            };

            bigval >>= shift;
            let got_u64 = bigval.low64();
            assert_eq!(got_u64, expected, "Random fuzz shift mismatch for shift={}", shift);
        }

        info!("Random-fuzz checks succeeded for `ShrAssign<u32>` on BaseUInt64.");
    }

    #[traced_test]
    fn shr_assign_u32_large_shift_clears_baseuint64() {
        info!("Testing large shifts that should clear BaseUInt64 completely.");

        let test_values: [u64; 4] = [
            0,
            1,
            0xFFFFFFFFFFFFFFFF,
            0xABCDEFFF12345678,
        ];
        let large_shifts: [u32; 5] = [64, 65, 66, 100, 999];

        for &val_u64 in &test_values {
            for &shift in &large_shifts {
                let mut bigval = BaseUInt64::from(val_u64);
                bigval >>= shift;
                assert_eq!(
                    bigval.low64(), 
                    0,
                    "Expected zero result for shift={} >=64, val=0x{:016X}",
                    shift, val_u64
                );
            }
        }

        info!("Confirmed large shifts zero out BaseUInt64 as expected.");
    }

    #[traced_test]
    fn shr_assign_u32_no_op_for_zero_bits() {
        info!("Testing that `ShrAssign<u32>(0)` does nothing.");

        let test_values: [u64; 5] = [
            0,
            1,
            0xFFFFFFFFFFFFFFFF,
            0x123456789ABCDEF0,
            0x00FF00FF00FF00FF,
        ];

        for &val_u64 in &test_values {
            let mut bigval = BaseUInt64::from(val_u64);
            bigval >>= 0;
            assert_eq!(bigval.low64(), val_u64);
        }

        info!("Confirmed `ShrAssign<u32>(0)` leaves BaseUInt64 unchanged.");
    }
}