Function test_pack_bytes_less_than_n

src/pack.rs:671–729

()

    bench_n!(bench_unpack_arithmetic, 2, 3, 4, 6, 16);

    fn test_pack_bytes_less_than_n<const N: usize, const FACTOR: usize>() {
        for n in [1, 11, 97, 991, 10007].into_iter().flat_map(|n_prime| {
            let divisor = if FACTOR == 256 {
                1
            } else {
                super::factor_to_divisor::<FACTOR>()
            };
            let n_factor = crate::nightly::div_ceil_usize(n_prime, divisor) * divisor;
            [n_factor, n_prime]
        }) {
            let bytes: Vec<_> = crate::random_data(n)
                .into_iter()
                .map(|v: usize| (v % N as usize) as u8)
                .collect();
            let n = bytes.len(); // random_data shrinks n on miri.

            println!("n {n}, N {N}, FACTOR {FACTOR}");
            if N != FACTOR {
                let mut bytes = bytes.clone();
                bytes[n - 1] = (FACTOR - 1) as u8; // Make least 1 byte is out of bounds.
                let mut packed = vec![];
                super::pack_bytes_less_than::<FACTOR>(&bytes, &mut packed);

                assert!(super::unpack_bytes_less_than::<N, 0>(
                    &mut packed.as_slice(),
                    bytes.len(),
                    &mut crate::fast::CowSlice::default()
                )
                .is_err());
                assert!(super::unpack_bytes_less_than::<N, N>(
                    &mut packed.as_slice(),
                    bytes.len(),
                    &mut crate::fast::CowSlice::default()
                )
                .is_err());
            }

            let mut packed = vec![];
            super::pack_bytes_less_than::<N>(&bytes, &mut packed);

            let mut input = packed.as_slice();
            let mut unpacked = crate::fast::CowSlice::default();
            super::unpack_bytes_less_than::<N, 0>(&mut input, bytes.len(), &mut unpacked).unwrap();
            assert!(input.is_empty());
            assert_eq!(unsafe { unpacked.as_slice(bytes.len()) }, bytes);

            let mut input = packed.as_slice();
            let mut unpacked = crate::fast::CowSlice::default();
            let histogram =
                super::unpack_bytes_less_than::<N, N>(&mut input, bytes.len(), &mut unpacked)
                    .unwrap();
            assert!(input.is_empty());
            assert_eq!(unsafe { unpacked.as_slice(bytes.len()) }, bytes);
            assert_eq!(
                histogram.as_slice(),
                &crate::histogram::histogram(&bytes)[..N]
            );
        }