entropic 0.1.1

#[cfg(feature = "derive")]
mod derive {
    use entropic::prelude::*;

    use entropic_derive::Entropic;

    #[derive(Entropic)]
    struct UnitStruct01;

    #[test]
    fn unit_struct_bijection() {
        let mut buf = [0u8; 1];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnitStruct01::from_entropy_source(&mut s).unwrap();
        assert!(s.get_byte().is_ok());
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(buf.as_mut_slice())
            .unwrap();
        assert!(len == 0);
    }

    #[derive(Entropic)]
    struct UnnamedStruct01(u32, String);

    #[test]
    fn unnamed_struct_small() {
        let buf = [0u8; 5];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnnamedStruct01::from_entropy_source(&mut s).unwrap();
        assert!(u.0 == 0);
        assert!(u.1.len() == 0);
        assert!(!s.get_byte().is_ok());

        let mut dst_buf = [0xff; 5];
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(dst_buf.as_mut_slice())
            .unwrap();
        assert!(len == 5, "length was {}", len);
        assert!(buf == dst_buf);
    }

    #[test]
    fn unnamed_struct_medium() {
        let buf = [1, 0, 0, 0, 3, b'a', b's', b'd'];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnnamedStruct01::from_entropy_source(&mut s).unwrap();
        assert!(u.0 == 1);
        assert!(u.1.as_str() == "asd");
        assert!(!s.get_byte().is_ok());

        let mut dst_buf = [0xff; 8];
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(dst_buf.as_mut_slice())
            .unwrap();
        assert!(len == 8, "length was {}", len);
        assert!(buf == dst_buf);
    }

    #[derive(Entropic)]
    struct UnnamedStruct02();

    #[derive(Entropic)]
    struct UnnamedStruct03(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8);

    #[test]
    fn unnamed_struct_large() {
        let mut buf = [8, 7, 6, 5, 4, 3, 2, 1, 0, 11, 22, 33];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnnamedStruct03::from_entropy_source(&mut s).unwrap();
        assert!(u.0 == 8);
        assert!(u.1 == 7);
        assert!(u.2 == 6);
        assert!(u.3 == 5);
        assert!(u.4 == 4);
        assert!(u.5 == 3);
        assert!(u.6 == 2);
        assert!(u.7 == 1);
        assert!(u.8 == 0);
        assert!(u.9 == 11);
        assert!(u.10 == 22);
        assert!(u.11 == 33);
        assert!(!s.get_byte().is_ok());
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(buf.as_mut_slice())
            .unwrap();
        assert!(len == 12, "length was {}", len);
    }

    #[derive(Entropic)]
    struct NamedStruct01 {
        f1: u8,
        f2: String,
        f3: Box<u16>,
    }


    #[test]
    fn named_struct_small() {
        let mut buf = [0u8; 4];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = NamedStruct01::from_entropy_source(&mut s).unwrap();
        assert!(u.f1 == 0);
        assert!(u.f2.as_str() == "");
        assert!(u.f3 == Box::new(0u16));
        assert!(!s.get_byte().is_ok());
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(buf.as_mut_slice())
            .unwrap();
        assert!(len == 4, "length was {}", len);
    }

    #[derive(PartialEq, Eq, Entropic)]
    enum UnitEnum01 {
        A,
        B,
        C,
    }

    #[test]
    fn unit_enum_small() {
        let mut buf = [2u8; 1];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnitEnum01::from_entropy_source(&mut s).unwrap();
        assert!(u == UnitEnum01::C);
        assert!(!s.get_byte().is_ok());
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(buf.as_mut_slice())
            .unwrap();
        assert!(len == 1, "length was {}", len);
    }

    #[derive(PartialEq, Eq, Entropic)]
    enum UnitEnum02 {
        A,
    }

    #[test]
    fn unit_enum_singular() {
        let mut buf = [8u8; 1];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnitEnum02::from_entropy_source(&mut s).unwrap();
        assert!(u == UnitEnum02::A);
        assert!(s.get_byte().is_ok());
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(buf.as_mut_slice())
            .unwrap();
        assert!(len == 0, "length was {}", len);
    }

    #[derive(Entropic)]
    enum UnnamedEnum01 {
        A(u8, u16, String),
        B(u8),
    }

    #[test]
    fn unit_enum_unnamed() {
        let buf = [0u8, 6u8, 12u8, 0u8, 1u8, b'a'];
        let mut s: Source<'_, _, DefaultEntropyScheme> = Source::new(buf.iter());
        let u = UnnamedEnum01::from_entropy_source(&mut s).unwrap();

        match &u {
            UnnamedEnum01::A(a, b, c) => {
                assert!(*a == 6);
                assert!(*b == 12);
                assert!(c.as_str() == "a");
            }
            _ => assert!(false, "UnnamedEnum01 didn't match type A"),
        }

        assert!(!s.get_byte().is_ok());

        let mut dst_buf = [0xff; 6];
        let len = u
            .to_entropy::<_, DefaultEntropyScheme>(dst_buf.as_mut_slice())
            .unwrap();
        assert!(len == 6, "length was {}", len);
        assert!(buf == dst_buf);
    }

    #[test]
    fn test_unnamed_enum() {}

    #[derive(Entropic)]
    enum NamedEnum01 {
        A { f1: u8, f2: u16, f3: String },
        B { f1: u8 },
        C {},
    }
}