tiny-bitstream 0.1.0

use std::convert::{TryFrom, TryInto};

use rand::seq::SliceRandom;
use rand::Rng;

use crate::{
    constants::{BitContainer, BIT_MASK, CTNR_BYTES_SIZE, CTNR_SIZE},
    errors::BitStreamError,
    get_lower_bits, BitDstream, BitEstream, BitReader, BitWriter,
};

#[test]
fn read_write_different_sizes() {
    // Write an u32, expect a vec of len 4
    let mut estream = BitEstream::new();
    estream
        .add_bits(u32::MAX as usize, u32::BITS as u8)
        .unwrap();
    let vec: Vec<u8> = estream.into();
    assert_eq!(vec.len(), 5);
    println!("{:?}", vec);
    for byte in vec.iter().take(4) {
        println!("hihi");
        assert_eq!(*byte, u8::MAX);
    }
    let mut dstream: BitDstream = vec.try_into().unwrap();
    dstream.read_bits(1).unwrap(); // read endmark
    dstream.reload_container().unwrap();
    let res = dstream.read_bits(u32::BITS as u8).unwrap();
    assert_eq!(res, u32::MAX as usize);

    let mut estream = BitEstream::new();
    estream.add_bits(u8::MAX as usize, u8::BITS as u8).unwrap();
    let vec: Vec<u8> = estream.into();
    assert_eq!(vec.len(), 2);
    for byte in vec.iter().take(1) {
        assert_eq!(*byte, u8::MAX);
    }
    let mut dstream: BitDstream = vec.try_into().unwrap();
    dstream.read_bits(1).unwrap(); // read endmark
    dstream.reload_container().unwrap();
    let res = dstream.read_bits(u8::BITS as u8).unwrap();
    assert_eq!(res, u8::MAX as usize);

    let mut estream = BitEstream::new();
    estream
        .add_bits(u64::MAX as usize, u64::BITS as u8)
        .unwrap();
    let vec: Vec<u8> = estream.into();
    assert_eq!(vec.len(), 9);
    for byte in vec.iter().take(8) {
        assert_eq!(*byte, u8::MAX);
    }
    let mut dstream: BitDstream = vec.try_into().unwrap();
    dstream.read_bits(1).unwrap(); // read endmark
    dstream.reload_container().unwrap();
    let res = dstream.read_bits(u64::BITS as u8).unwrap();
    assert_eq!(res, u64::MAX as usize);
}

#[test]
fn test_buffer_overflow() {
    // adding more than 64 bits in the container should return an error
    let mut estream = BitEstream::new();
    estream.add_bits(0u64 as usize, u64::BITS as u8).unwrap();
    match estream.add_bits(0u8 as usize, u64::BITS as u8) {
        Err(BitStreamError::AddBits(err)) => assert_eq!(err, "Container overflow"),
        _ => panic!("expected error here"),
    };
}

#[test]
fn test_write_trait_prototype() {
    let mut estream = BitEstream::new();
    estream.unchecked_write(0, (u64::BITS - 3) as u8);
    estream.unchecked_write(255, 8);

    let v: Vec<u8> = estream.into();
    let expected = &[
        0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000,
        0b11100000, 0b00111111,
    ];
    for (a, b) in v.iter().zip(expected) {
        assert_eq!(a, b);
    }
}

#[test]
fn test_read_write_traits_prototype() {
    let mut estream = BitEstream::new();
    estream.unchecked_write(0, (u64::BITS - 3) as u8);
    estream.unchecked_write(255, 8);
    let v: Vec<u8> = estream.into();
    for a in v.iter() {
        println!("{:08b}", a);
    }
    let mut dstream: BitDstream = v.try_into().unwrap();
    for a in dstream.stream.iter() {
        println!("{:08b}", a);
    }
    println!("ctnr {:064b}", dstream.bits_container);
    println!("ctnr {}", dstream.bits_consumed);
    assert_eq!(dstream.read(1).unwrap(), 1); // read endmark
    println!("ctnr {:064b}", dstream.bits_container);
    println!("ctnr {}", dstream.bits_consumed);
    assert_eq!(dstream.read(8).unwrap(), 255);
    println!("ctnr {:064b}", dstream.bits_container);
    println!("ctnr {}", dstream.bits_consumed);
    assert_eq!(dstream.read((u64::BITS - 3) as u8).unwrap(), 0);

    // todo: check if overflow handled (change panics into errors)
    // assert!(dstream.read((u64::BITS - 3) as u8).is_err());
}

#[test]
fn another_random_read_write_test() {
    let mut buffer = vec![];
    for _ in 0..5 {
        buffer.push(rand::random::<u32>())
    }
    let mut estream = BitEstream::new();
    for v in buffer.iter() {
        println!(
            "write {:032b} {v}, with {} bits",
            v,
            u32::BITS - v.leading_zeros()
        );
        estream.unchecked_write(*v as usize, (u32::BITS - v.leading_zeros()) as u8);
    }
    buffer.reverse();

    let v: Vec<u8> = estream.try_into().unwrap();

    println!();
    for b in v.iter() {
        println!("my v {:08b}", b);
    }
    println!();

    let mut dstream: BitDstream = v.try_into().unwrap();
    assert_eq!(dstream.read(1).unwrap(), 1); // read endmark
    for v in buffer {
        println!(
            "try to read {v} with {} bits",
            u32::BITS - v.leading_zeros()
        );
        assert_eq!(
            dstream.read((u32::BITS - v.leading_zeros()) as u8).unwrap(),
            v as usize
        );
    }
}

#[test]
fn stream_reader_correctly_consumed() {
    let mut dstream = BitDstream {
        bits_container: 25,
        bits_consumed: 64,
        stream: vec![],
    };

    dstream.reload_container().unwrap();

    println!("{}", dstream.bits_consumed);
}

#[test]
fn test_lifo() {
    // adding more than 64 bits in the container should return an error
    let mut estream = BitEstream::new();
    estream.add_bits(1usize, 1).unwrap();
    estream.add_bits(0usize, 1).unwrap();
    estream.add_bits(0usize, 1).unwrap();
    estream.close_stream().unwrap();

    let mut dstream: BitDstream = estream.try_into().unwrap();
    dstream.read_bits(1).unwrap(); // end mark

    assert_eq!(dstream.read_bits(1).unwrap(), 0);
    assert_eq!(dstream.read_bits(1).unwrap(), 0);
    assert_eq!(dstream.read_bits(1).unwrap(), 1);
}

#[test]
fn curiosity_test_write() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    println!("Start building a random buffer");
    let mut rng = rand::thread_rng();
    //let len = rng.gen::<u8>() as usize;
    let len = 10;
    let mut buffer: Vec<u8> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    println!("Random buffer of {} elements builded", len);
    println!("{:?}\n", buffer);
    println!("Start write byte by byte");
    let mut e_stream = BitEstream::new();
    const BYTE_LEN: u8 = 8;
    for (i, byte) in buffer.iter().enumerate() {
        if i > 0 && i % CTNR_BYTES_SIZE == 0 {
            e_stream.flush_bits();
        }
        if let Err(err) = e_stream.add_bits(*byte as BitContainer, BYTE_LEN) {
            panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            )
        }
    }

    println!("Close stream");
    e_stream.close_stream().unwrap();

    println!("Just looking at the stream for curiosity");
    println!("{:?}\n", e_stream.stream);

    println!("Start a decoding stream");
    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!("Read the bit endmark");
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    println!("Looking at the {} firsts bytes", CTNR_BYTES_SIZE);
    println!("{:?}", d_stream.bits_container.to_be_bytes().to_vec());

    println!(
        "And we can also look at the full stream\n{:?}\n",
        d_stream.stream
    );

    buffer.reverse();
    for (i, byte) in buffer.iter().enumerate() {
        if i > 0 && i % CTNR_BYTES_SIZE == 0 {
            println!("reload");
            d_stream.reload_container().unwrap();
            println!("Looking at the {} firsts bytes", CTNR_BYTES_SIZE);
            println!("{:?}", d_stream.bits_container.to_be_bytes().to_vec());
        }
        let b = match d_stream.read_bits(BYTE_LEN) {
            Ok(read_bits) => {
                u8::try_from(read_bits).expect("This value was supposed to be a single byte")
            }
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        assert_eq!(*byte, b);
    }
}

#[test]
fn write_u8() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    let mut rng = rand::thread_rng();
    let len = rng.gen::<u8>() as usize;
    let mut buffer: Vec<u8> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    let mut e_stream = BitEstream::new();
    const BYTE_LEN: u8 = 8;
    for (i, byte) in buffer.iter().enumerate() {
        if i > 0 && i % CTNR_BYTES_SIZE == 0 {
            e_stream.flush_bits();
        }
        if let Err(err) = e_stream.add_bits(*byte as BitContainer, BYTE_LEN) {
            panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            )
        }
    }
    e_stream.close_stream().unwrap();
    let mut d_stream = BitDstream::try_from(e_stream).unwrap();

    println!("Read the bit endmark");
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    buffer.reverse();
    for (i, byte) in buffer.iter().enumerate() {
        if i > 0 && i % CTNR_BYTES_SIZE == 0 {
            d_stream.reload_container().unwrap();
        }
        let b = match d_stream.read_bits(BYTE_LEN) {
            Ok(read_bits) => {
                u8::try_from(read_bits).expect("This value was supposed to be a single byte")
            }
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        assert_eq!(*byte, b);
    }
}

#[test]
fn write_full_ctnr() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    println!("Start building a random buffer");
    let mut rng = rand::thread_rng();
    let len = rng.gen::<u8>() as usize;
    let mut buffer: Vec<BitContainer> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    println!("Random buffer of {} elements builded", len);
    println!("Start write byte by byte");
    let mut e_stream = BitEstream::new();

    for byte in buffer.iter() {
        if let Err(err) = e_stream.add_bits(*byte as BitContainer, CTNR_SIZE) {
            panic!("Failed .. {}", err)
        }
        e_stream.flush_bits();
    }

    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!("Read the bit endmark");
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    buffer.reverse();
    for (i, bytes) in buffer.iter().enumerate() {
        let b: BitContainer = match d_stream.read_bits(CTNR_SIZE) {
            Ok(read_bits) => read_bits,
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        d_stream.reload_container().unwrap();
        assert_eq!(*bytes, b);
    }
}

#[cfg(target_pointer_width = "64")]
#[test]
fn write_half_ctnr() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    println!("Start building a random buffer");
    let mut rng = rand::thread_rng();
    let len = rng.gen::<u8>() as usize;
    let mut buffer: Vec<u32> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    println!("Random buffer of {} elements builded", len);
    println!("Start write byte by byte");
    let mut e_stream = BitEstream::new();

    for (i, byte) in buffer.iter().enumerate() {
        if i % 2 == 0 {
            e_stream.flush_bits();
        }
        if let Err(err) = e_stream.add_bits(*byte as BitContainer, CTNR_SIZE / 2) {
            panic!("Failed at {}(%{}) .. {}", i, i % 2, err)
        }
        e_stream.flush_bits();
    }

    let _: Vec<u8> = e_stream.into();
}

#[test]
/// In this test, we will try to write bit/bit and check if the sum
/// is correct.
fn writing_test() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    let mut rng = rand::thread_rng();
    //let len = rng.gen::<u8>() as usize;
    let len = 10;
    let mut buffer: Vec<BitContainer> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    println!("Random buffer of {} elements builded\n{:?}\n", len, buffer);

    println!("Start write byte by byte");
    let mut e_stream = BitEstream::new();

    for byte in buffer.iter() {
        println!("byte: {:#b}", *byte);
        for i in 0..CTNR_SIZE {
            let b = (*byte >> i) & 1;
            //println!("bit i: {:#b}", b);
            if let Err(err) = e_stream.add_bits(b, 1) {
                panic!("Failed .. {}", err)
            }
        }
        //println!("Container: {:?}", e_stream.bits_container);
        e_stream.flush_bits();
    }

    e_stream.close_stream().unwrap();

    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!("Read the bit endmark");
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    buffer.reverse();
    for (i, bytes) in buffer.iter().enumerate() {
        let b: BitContainer = match d_stream.read_bits(CTNR_SIZE) {
            Ok(read_bits) => read_bits,
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        d_stream.reload_container().unwrap();
        assert_eq!(*bytes, b);
    }
}

#[cfg(target_pointer_width = "64")]
#[test]
/// Same as writing test but we print n random bits by n random bits
fn writing_test_2() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    let mut rng = rand::thread_rng();
    //let len = rng.gen::<u8>() as usize;
    let len = 10;
    let mut buffer: Vec<BitContainer> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    println!("Random buffer of {} elements builded\n{:?}\n", len, buffer);

    let mut e_stream = BitEstream::new();

    let mut n_rnd = [3u8, 2, 2, 1];
    for byte in buffer.iter() {
        let mut byte = *byte;
        println!("byte: {:#b}", byte);
        n_rnd.shuffle(&mut rng);
        for ele in n_rnd {
            let b = byte & BIT_MASK[(ele * 8) as usize];
            byte >>= (ele * 8) as usize;
            if let Err(err) = e_stream.add_bits(b, ele * 8) {
                panic!("Failed .. {}", err)
            }
        }
        //println!("Container: {:?}", e_stream.bits_container);
        e_stream.flush_bits();
    }

    e_stream.close_stream().unwrap();

    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!("Read the bit endmark");
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    buffer.reverse();
    for (i, bytes) in buffer.iter().enumerate() {
        let b: BitContainer = match d_stream.read_bits(CTNR_SIZE) {
            Ok(read_bits) => read_bits,
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        d_stream.reload_container().unwrap();
        assert_eq!(*bytes, b);
    }
}

#[test]
fn writing_test_3() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    let mut rng = rand::thread_rng();
    let len = 10;
    let mut buffer: Vec<BitContainer> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    println!("Random buffer of {} elements builded\n{:?}\n", len, buffer);

    let mut e_stream = BitEstream::new();

    let mut n_rnd = [2u8, 1, 1];
    for byte in buffer.iter() {
        let mut byte = *byte;
        for _ in 0..=1 {
            n_rnd.shuffle(&mut rng);
            for ele in n_rnd {
                let b = byte & BIT_MASK[(ele * 8) as usize];
                byte >>= (ele * 8) as usize;
                if let Err(err) = e_stream.add_bits(b, ele * 8) {
                    panic!("Failed .. {}", err)
                }
            }
            //println!("Container: {:?}", e_stream.bits_container);
            e_stream.flush_bits();
        }
    }

    e_stream.close_stream().unwrap();

    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!("Read the bit endmark");
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    buffer.reverse();
    for (i, bytes) in buffer.iter().enumerate() {
        let b: BitContainer = match d_stream.read_bits(CTNR_SIZE) {
            Ok(read_bits) => read_bits,
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        d_stream.reload_container().unwrap();
        assert_eq!(*bytes, b);
    }
}

#[test]
/// Write unaligned bits and try to read
fn endmark_test() {
    let mut rng = rand::thread_rng();
    let nb_bits: u8 = rng.gen_range(1..31);
    let rnd_num = rng.gen();
    let bits = get_lower_bits(rnd_num, nb_bits).unwrap_or_else(|_| {
        panic!(
            "Failed to get {} bits of {:b}({})",
            nb_bits, rnd_num, rnd_num
        )
    });
    println!(
        "Now we will try to write {} bits: {:b}({}), size",
        nb_bits, bits, bits
    );
    let mut e_stream = BitEstream::new();
    e_stream
        .add_bits(bits, nb_bits)
        .unwrap_or_else(|_| panic!("Failed to add {:b}", bits));
    println!(
        "- Save the e_stream container before closing it:\n{:b}",
        e_stream.bits_container
    );
    let ctnr = e_stream.bits_container;
    e_stream.close_stream().unwrap();
    println!(
        "- Look at the stream container after closing it:\n{:?}",
        e_stream.stream
    );
    println!(
        "- The container of e_stream should be empty: {}",
        e_stream.bits_container == 0
    );
    assert_eq!(e_stream.bits_container, 0);

    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!(
        "The stream vector should have been drained: {}",
        d_stream.stream.is_empty()
    );
    assert!(d_stream.stream.is_empty());

    println!("- Check d_stream container:\n{:b}", d_stream.bits_container);
    let has_endmark = ctnr + (1 << nb_bits) == d_stream.bits_container;
    println!(
        "- The new container should have an endmark: {}",
        has_endmark
    );
    assert!(has_endmark);

    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    let ret = d_stream.read_bits(nb_bits).unwrap_or_else(|_| {
        panic!(
            "Failed to get {} bits of {:b}({})",
            nb_bits, rnd_num, rnd_num
        )
    });
    assert_eq!(bits, ret)
}

#[cfg(target_pointer_width = "64")]
#[test]
/// Write unaligned bits and try to read
fn endmark_test_limit() {
    let mut rng = rand::thread_rng();
    let nb_bits: u8 = 64;
    let rnd_num = rng.gen();
    let bits = get_lower_bits(rnd_num, nb_bits).unwrap_or_else(|_| {
        panic!(
            "Failed to get {} bits of {:b}({})",
            nb_bits, rnd_num, rnd_num
        )
    });
    println!(
        "Now we will try to write {} bits: {:b}({}), size",
        nb_bits, bits, bits
    );
    let mut e_stream = BitEstream::new();
    e_stream
        .add_bits(bits, nb_bits)
        .unwrap_or_else(|_| panic!("Failed to add {:b}", bits));
    println!(
        "- Save the e_stream container before closing it:\n{:b}",
        e_stream.bits_container
    );
    let ctnr = e_stream.bits_container;
    e_stream.close_stream().unwrap();
    println!(
        "- Look at the stream container after closing it:\n{:?}",
        e_stream.stream
    );
    println!(
        "- The container of e_stream should be empty: {}",
        e_stream.bits_container == 0
    );
    assert_eq!(e_stream.bits_container, 0);

    let expected_ctnr = ((ctnr >> 1) | (1 << 63)) >> 7;
    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!(
        "Just look at the containers:\n\t- prev: {:064b}\n\t- curr: {:064b}\n\t- expe: {:064b}",
        ctnr, d_stream.bits_container, expected_ctnr
    );
    let has_endmark = expected_ctnr == d_stream.bits_container;
    println!("- Expected container read: {}", has_endmark);
    assert!(has_endmark);

    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();
    println!(
        "Just look at the containers after reload:\n{:064b}",
        d_stream.bits_container
    );
    let ret = d_stream.read_bits(nb_bits).unwrap_or_else(|_| {
        panic!(
            "Failed to get {} bits of {:b}({})",
            nb_bits, rnd_num, rnd_num
        )
    });
    assert_eq!(bits, ret)
}

#[cfg(target_pointer_width = "32")]
#[test]
/// Write unaligned bits and try to read
fn endmark_test_limit() {
    let mut rng = rand::thread_rng();
    let nb_bits: u8 = 32;
    let rnd_num = rng.gen();
    let bits = get_lower_bits(rnd_num, nb_bits).unwrap_or_else(|_| {
        panic!(
            "Failed to get {} bits of {:b}({})",
            nb_bits, rnd_num, rnd_num
        )
    });
    println!(
        "Now we will try to write {} bits: {:b}({}), size",
        nb_bits, bits, bits
    );
    let mut e_stream = BitEstream::new(4).unwrap();
    e_stream
        .add_bits(bits, nb_bits)
        .unwrap_or_else(|_| panic!("Failed to add {:b}", bits));
    println!(
        "- Save the e_stream container before closing it:\n{:b}",
        e_stream.bits_container
    );
    let ctnr = e_stream.bits_container;
    e_stream.close_stream().unwrap();
    println!(
        "- Look at the stream container after closing it:\n{:?}",
        e_stream.stream
    );
    println!(
        "- The container of e_stream should be empty: {}",
        e_stream.bits_container == 0
    );
    assert_eq!(e_stream.bits_container, 0);

    let expected_ctnr = ((ctnr >> 1) | (1 << 31)) >> 7;
    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    println!(
        "Just look at the containers:\n\t- prev: {:064b}\n\t- curr: {:064b}\n\t- expe: {:064b}",
        ctnr, d_stream.bits_container, expected_ctnr
    );
    let has_endmark = expected_ctnr == d_stream.bits_container;
    println!("- Expected container read: {}", has_endmark);
    assert!(has_endmark);

    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();
    println!(
        "Just look at the containers after reload:\n{:064b}",
        d_stream.bits_container
    );
    let ret = d_stream.read_bits(nb_bits).unwrap_or_else(|_| {
        panic!(
            "Failed to get {} bits of {:b}({})",
            nb_bits, rnd_num, rnd_num
        )
    });
    assert_eq!(bits, ret)
}

#[test]
/// Same as end_mar test but try 20 times with randoms values
/// and doesn't write output
fn silent_endmark_test() {
    let mut rng = rand::thread_rng();
    for _ in 0..20 {
        let nb_bits: u8 = rng.gen_range(1..31);
        let rnd_num = rng.gen();
        let bits = get_lower_bits(rnd_num, nb_bits).unwrap_or_else(|_| {
            panic!(
                "Failed to get {} bits of {:b}({})",
                nb_bits, rnd_num, rnd_num
            )
        });
        let mut e_stream = BitEstream::new();
        e_stream
            .add_bits(bits, nb_bits)
            .unwrap_or_else(|_| panic!("Failed to add {:b}", bits));
        e_stream.close_stream().unwrap();
        assert_eq!(e_stream.bits_container, 0);
        let mut d_stream = BitDstream::try_from(e_stream).unwrap();
        assert!(d_stream.stream.is_empty());
        d_stream.read_bits(1u8).unwrap();
        d_stream.reload_container().unwrap();
        let ret = d_stream.read_bits(nb_bits).unwrap_or_else(|_| {
            panic!(
                "Failed to get {} bits of {:b}({})",
                nb_bits, rnd_num, rnd_num
            )
        });
        assert_eq!(bits, ret);
    }
}

#[test]
/// Same as write_u8 but with a consequent amount of bytes
fn big_test() {
    println!("Build info:");
    println!(" - `CTNR_BYTES_SIZE`: {}", CTNR_BYTES_SIZE);
    let mut rng = rand::thread_rng();
    let len = 10_000;
    let mut buffer: Vec<u8> = Vec::with_capacity(len);
    for _ in 0..len {
        buffer.push(rng.gen());
    }
    let mut e_stream = BitEstream::new();
    const BYTE_LEN: u8 = 8;
    for (i, byte) in buffer.iter().enumerate() {
        if i > 0 && i % CTNR_BYTES_SIZE == 0 {
            e_stream.flush_bits();
        }
        if let Err(err) = e_stream.add_bits(*byte as BitContainer, BYTE_LEN) {
            panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            )
        }
    }
    e_stream.close_stream().unwrap();
    let mut d_stream = BitDstream::try_from(e_stream).unwrap();
    d_stream.read_bits(1).unwrap();
    d_stream.reload_container().unwrap();

    buffer.reverse();
    for (i, byte) in buffer.iter().enumerate() {
        if i > 0 && i % CTNR_BYTES_SIZE == 0 {
            d_stream.reload_container().unwrap();
        }
        let b = match d_stream.read_bits(BYTE_LEN) {
            Ok(read_bits) => {
                u8::try_from(read_bits).expect("This value was supposed to be a single byte")
            }
            Err(err) => panic!(
                "Failed to write buffer at {}({}) .. {}",
                i,
                i % CTNR_BYTES_SIZE,
                err
            ),
        };
        assert_eq!(*byte, b);
    }
}