use num_bigint::BigUint;
pub fn bit_count(n: u64) -> usize {
if n == 0 {
return 0;
}
(u64::BITS - n.leading_zeros()) as usize
}
pub fn byte_count(n: u64) -> usize {
bit_count(n).div_ceil(8)
}
pub fn int_to_bin(n: u64, min_len: usize) -> Vec<u8> {
let raw = n.to_be_bytes();
let first_set = raw.iter().position(|&b| b != 0).unwrap_or(8);
let sig_bytes = 8 - first_set;
if sig_bytes >= min_len {
raw[first_set..].to_vec()
} else {
if min_len > 8 {
let mut v = vec![0u8; min_len - 8];
v.extend_from_slice(&raw);
v
} else {
raw[8 - min_len..].to_vec()
}
}
}
pub fn big_uint_to_bytes(n: &BigUint) -> Vec<u8> {
use num_traits::Zero;
if n.is_zero() {
return vec![];
}
n.to_bytes_be()
}
pub fn bytes_to_big_uint(bytes: &[u8]) -> BigUint {
BigUint::from_bytes_be(bytes)
}
pub fn bytes_to_big_uint_le(bytes: &[u8]) -> BigUint {
BigUint::from_bytes_le(bytes)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bit_count_zero() {
assert_eq!(bit_count(0), 0);
}
#[test]
fn bit_count_one() {
assert_eq!(bit_count(1), 1);
}
#[test]
fn bit_count_two() {
assert_eq!(bit_count(2), 2);
}
#[test]
fn bit_count_three() {
assert_eq!(bit_count(3), 2);
}
#[test]
fn bit_count_255() {
assert_eq!(bit_count(255), 8);
}
#[test]
fn bit_count_256() {
assert_eq!(bit_count(256), 9);
}
#[test]
fn bit_count_max_u64() {
assert_eq!(bit_count(u64::MAX), 64);
}
#[test]
fn byte_count_zero() {
assert_eq!(byte_count(0), 0);
}
#[test]
fn byte_count_one() {
assert_eq!(byte_count(1), 1);
}
#[test]
fn byte_count_ff() {
assert_eq!(byte_count(0xFF), 1);
}
#[test]
fn byte_count_100() {
assert_eq!(byte_count(0x100), 2);
}
#[test]
fn byte_count_ffff() {
assert_eq!(byte_count(0xFFFF), 2);
}
#[test]
fn byte_count_10000() {
assert_eq!(byte_count(0x10000), 3);
}
#[test]
fn byte_count_ffffff() {
assert_eq!(byte_count(0xFFFFFF), 3);
}
#[test]
fn int_to_bin_zero_min1() {
assert_eq!(int_to_bin(0, 1), vec![0x00]);
}
#[test]
fn int_to_bin_zero_min0() {
assert_eq!(int_to_bin(0, 0), vec![]);
}
#[test]
fn int_to_bin_one_min1() {
assert_eq!(int_to_bin(1, 1), vec![0x01]);
}
#[test]
fn int_to_bin_one_min0() {
assert_eq!(int_to_bin(1, 0), vec![0x01]);
}
#[test]
fn int_to_bin_0x100_min1() {
assert_eq!(int_to_bin(0x100, 1), vec![0x01, 0x00]);
}
#[test]
fn int_to_bin_four_min0() {
assert_eq!(int_to_bin(4, 0), vec![0x04]);
}
#[test]
fn int_to_bin_0x12_min0() {
assert_eq!(int_to_bin(0x12, 0), vec![0x12]);
}
#[test]
fn int_to_bin_0xff_min2() {
assert_eq!(int_to_bin(0xFF, 2), vec![0x00, 0xFF]);
}
#[test]
fn int_to_bin_0x0001_min1() {
assert_eq!(int_to_bin(0x0001, 1), vec![0x01]);
}
#[test]
fn int_to_bin_0xffff_min1() {
assert_eq!(int_to_bin(0xFFFF, 1), vec![0xFF, 0xFF]);
}
#[test]
fn int_to_bin_large_value() {
assert_eq!(
int_to_bin(0x01_0000_0000, 1),
vec![0x01, 0x00, 0x00, 0x00, 0x00]
);
}
#[test]
fn int_to_bin_min_len_forces_padding() {
assert_eq!(int_to_bin(1, 4), vec![0x00, 0x00, 0x00, 0x01]);
}
#[test]
fn int_to_bin_default_min1_nonzero() {
assert_eq!(int_to_bin(255, 1), vec![0xFF]);
}
#[test]
fn big_uint_to_bytes_zero() {
assert_eq!(big_uint_to_bytes(&BigUint::from(0u8)), vec![]);
}
#[test]
fn big_uint_to_bytes_one() {
assert_eq!(big_uint_to_bytes(&BigUint::from(1u8)), vec![0x01]);
}
#[test]
fn big_uint_to_bytes_256() {
assert_eq!(big_uint_to_bytes(&BigUint::from(256u16)), vec![0x01, 0x00]);
}
#[test]
fn big_uint_to_bytes_large() {
let n = BigUint::from(0xDEADBEEFu64);
assert_eq!(big_uint_to_bytes(&n), vec![0xDE, 0xAD, 0xBE, 0xEF]);
}
#[test]
fn bytes_to_big_uint_empty() {
assert_eq!(bytes_to_big_uint(&[]), BigUint::from(0u8));
}
#[test]
fn bytes_to_big_uint_one() {
assert_eq!(bytes_to_big_uint(&[0x01]), BigUint::from(1u8));
}
#[test]
fn bytes_to_big_uint_256() {
assert_eq!(bytes_to_big_uint(&[0x01, 0x00]), BigUint::from(256u16));
}
#[test]
fn bytes_to_big_uint_roundtrip() {
let original = BigUint::from(0xDEADBEEF_CAFEBABEu64);
let bytes = big_uint_to_bytes(&original);
let recovered = bytes_to_big_uint(&bytes);
assert_eq!(recovered, original);
}
#[test]
fn bytes_to_big_uint_le_basic() {
assert_eq!(bytes_to_big_uint_le(&[0x01, 0x00]), BigUint::from(1u8));
}
#[test]
fn bytes_to_big_uint_le_empty() {
assert_eq!(bytes_to_big_uint_le(&[]), BigUint::from(0u8));
}
}