trevors_utilities/tests/number_system_conversion.rs

use std::collections::BTreeMap;
use trevors_utilities::number_system_conversion::NumberSystemConversion;

#[test]
fn byte_to_bool_and_bool_to_byte() {
    // confirm a byte becomes a valid bool
    // **** NOTE THAT THIS VISUALLY IS BACKWARDS AS INDEX 0 IS FIRST AND LSB IS LAST ****
    let test_params: BTreeMap<u8, [bool; 8]> = BTreeMap::from([
        (0xff, [true, true, true, true, true, true, true, true]),
        (0x00, [
            false, false, false, false, false, false, false, false,
        ]),
        (0xa0, [false, false, false, false, false, true, false, true]),
    ]);

    for (src, dst) in test_params {
        assert_eq!(
            dst,
            NumberSystemConversion::byte_to_bool(src),
            "Unable to convert [{}] to [{:?}]",
            src,
            dst
        );
        assert_eq!(
            src,
            NumberSystemConversion::bool_to_byte(dst),
            "Unable to convert [{:?}] to [{}]",
            dst,
            src
        );
        assert_eq!(
            src,
            NumberSystemConversion::bool_to_byte(NumberSystemConversion::byte_to_bool(src))
        );
    }
}

#[test]
fn swap_endianness_u16() {
    let test_params: Vec<(u16, u16)> = vec![
        (0xabcd, 0xcdab),
        (0x0000, 0x0000),
        (0xffff, 0xffff),
        (0x00ff, 0xff00),
    ];

    for (src, dst) in test_params {
        assert_eq!(src, NumberSystemConversion::swap_endian_u16(dst));
        assert_eq!(
            src,
            NumberSystemConversion::swap_endian_u16(NumberSystemConversion::swap_endian_u16(src))
        );
        assert_eq!(dst, NumberSystemConversion::swap_endian_u16(src));
        assert_eq!(
            dst,
            NumberSystemConversion::swap_endian_u16(NumberSystemConversion::swap_endian_u16(dst))
        );
    }
}

#[test]
fn swap_endinness_u32() {
    let test_params: Vec<(u32, u32)> = vec![
        (0xabcdef01, 0x01efcdab),
        (0x12345678, 0x78563412),
        (0xbadbeef0, 0xf0eedbba),
    ];

    for (src, dst) in test_params {
        assert_eq!(src, NumberSystemConversion::swap_endian_u32(dst));
        assert_eq!(
            src,
            NumberSystemConversion::swap_endian_u32(NumberSystemConversion::swap_endian_u32(src))
        );
        assert_eq!(dst, NumberSystemConversion::swap_endian_u32(src));
        assert_eq!(
            dst,
            NumberSystemConversion::swap_endian_u32(NumberSystemConversion::swap_endian_u32(dst))
        );
    }
}

#[test]
fn split_bytes_u16_join_bytes_u16() {
    let test_params = BTreeMap::from([
        (0x0000, (0x00, 0x00)),
        (0xabcd, (0xab, 0xcd)),
        (0xffff, (0xff, 0xff)),
        (0xbeef, (0xbe, 0xef)),
    ]);

    for (joined, (high, low)) in test_params {
        assert_eq!((high, low), NumberSystemConversion::split_bytes_u16(joined));
        assert_eq!(
            joined,
            NumberSystemConversion::join_bytes_u16(high as u16, low as u16)
        );
    }
}

#[test]
fn combine_u8_to_u16() {
    let test_params: Vec<((u8, u8), u16)> = vec![
        ((0xff, 0x00), 0x00ff),
        ((0x00, 0xff), 0xff00),
        ((0xbe, 0xef), 0xefbe),
        ((0xef, 0xbe), 0xbeef),
    ];

    for ((low, high), base) in test_params {
        assert_eq!(base, NumberSystemConversion::combine_u8_to_u16(low, high))
    }
}

#[test]
fn clear_high_bits() {
    let test_params = vec![
        (0b1111_1111_0101_1010, 0b0000_0000_0101_1010),
        (0b1111_1111_1111_1111, 0b0000_0000_1111_1111),
        (0b0000_0000_1111_1111, 0b0000_0000_1111_1111),
        (0b0101_1010_1001_0110, 0b0000_0000_1001_0110)
    ];

    for (src, dst) in test_params {
        let result = NumberSystemConversion::clear_high_bits(src);
        println!("Rolled {src:016b} to {result:016b} / {dst:016b}");
        assert_eq!(
            NumberSystemConversion::clear_high_bits(src),
            dst);
    }

}

#[test]
fn clear_low_bits() {
    let test_params = vec![
        (0b1111_1111_0101_1010, 0b1111_1111_0000_0000),
        (0b1111_1111_1111_1111, 0b1111_1111_0000_0000),
        (0b0000_0000_1111_1111, 0b0000_0000_0000_0000),
        (0b0101_1010_1001_0110, 0b0101_1010_0000_0000)
    ];

    for (src, dst) in test_params {
        let result = NumberSystemConversion::clear_low_bits(src);
        println!("Rolled {src:08b} to {result:08b} / {dst:08b}");
        assert_eq!(
            NumberSystemConversion::clear_low_bits(src),
            dst);
    }
}