endecode 0.2.0

A simple encoding crate for types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

pub mod decode;
pub mod encode;

pub use decode::Decode;
pub use encode::Encode;

#[cfg(feature = "derive")]
pub use endecode_derive::{Decode, Encode};

#[cfg(test)]
mod test {
    use std::collections::HashMap;

    use rand::{thread_rng, Rng};

    use crate::{Decode, Encode};

    #[test]
    fn test_ints() {
        macro_rules! test_ints {
            ($rng:ident, $($t:ty),*) => {
                $(
                    for _ in 0..1024 {
                        let v = $rng.gen_range(<$t>::MIN..=<$t>::MAX);
                        assert_eq!(<$t>::decode(&mut v.encode().into_iter()), v);
                    }
                )*
            };
        }

        let mut rng = thread_rng();
        test_ints!(rng, u8, u16, u32, u64, u128, usize);
        test_ints!(rng, i8, i16, i32, i64, i128, isize);
    }

    #[test]
    fn test_vecs() {
        assert_eq!(
            Vec::<i32>::decode(
                &mut vec![
                    -1481226730,
                    -2050900860,
                    1398413233,
                    1179549798,
                    57731936,
                    987165288,
                    520248252,
                    -216621864,
                    310968107,
                    1116392241
                ]
                .encode()
                .into_iter()
            ),
            vec![
                -1481226730,
                -2050900860,
                1398413233,
                1179549798,
                57731936,
                987165288,
                520248252,
                -216621864,
                310968107,
                1116392241
            ]
        );
    }

    #[test]
    fn test_strs() {
        assert_eq!(
            "asd".encode(),
            vec![0, 0, 0, 0, 0, 0, 0, 3, 0x61, 0x73, 0x64]
        );
        assert_eq!(
            String::decode(&mut "asd".encode().into_iter()),
            "asd".to_owned()
        );
        assert_eq!(
            String::decode(&mut "asd".to_owned().encode().into_iter()),
            "asd".to_owned()
        );
    }

    #[test]
    fn test_hashmaps() {
        let mut map = HashMap::new();
        map.insert((0, 2, 5), "acf".to_owned());
        map.insert((20, 10, 0), "zka".to_owned());

        assert_eq!(HashMap::decode(&mut map.encode().into_iter()), map);
    }
}