rlibbencode 0.1.0

Rust Bencode library
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

pub mod variables;
mod utils;

#[macro_export]
macro_rules! bencode {
    ({ $($key:tt : $value:tt),* $(,)? }) => {{
        let mut ben = BencodeObject::new();
        $(
            ben.put($key, bencode!($value));
        )*
        ben
    }};

    ([ $($elem:tt),* $(,)? ]) => {{
        let mut ben = BencodeArray::new();
        $(
            ben.push(bencode!($elem));
        )*
        ben
    }};

    ($val:ident) => {{
        $val
    }};

    ($val:expr) => {{
        Box::<dyn BencodeVariable>::from($val)
    }};
}

#[cfg(test)]
mod tests {

    use crate::variables::bencode_object::BencodeObject;
    use crate::variables::bencode_array::BencodeArray;
    use crate::variables::bencode_object::PutObject;
    use crate::variables::bencode_array::AddArray;
    use crate::variables::bencode_bytes::BencodeBytes;
    use crate::variables::bencode_number::BencodeNumber;
    use crate::variables::inter::bencode_variable::{BencodeVariable, FromBencode, ToBencode};

    #[test]
    fn object() {
        let a = bencode!({
            "a": "HELLO WORLD",
            "b": 100.2
        });
        let b = BencodeObject::from_bencode(&a.to_bencode()).unwrap();
        assert_eq!(a.as_any().downcast_ref::<BencodeObject>().unwrap(), &b);

        let a = b"d1:a11:HELLO WORLD1:bi100.2ee";
        let b = BencodeObject::from_bencode(a).unwrap();
        assert_eq!(a.to_vec(), b.to_bencode());
        println!("Object encoding and decoding passed.");
    }

    #[test]
    fn array() {
        let a = bencode!([
            "HELLO WORLD",
            100.2
        ]);
        let b = BencodeArray::from_bencode(&a.to_bencode()).unwrap();
        assert_eq!(a.as_any().downcast_ref::<BencodeArray>().unwrap(), &b);

        let a = b"l11:HELLO WORLDi100.2ee";
        let b = BencodeArray::from_bencode(a).unwrap();
        assert_eq!(a.to_vec(), b.to_bencode());
        println!("Array encoding and decoding passed.");
    }

    #[test]
    fn number() {
        let a = bencode!(100.2);
        let b = BencodeNumber::from_bencode(&a.to_bencode()).unwrap();
        assert_eq!(a.as_any().downcast_ref::<BencodeNumber>().unwrap(), &b);

        let a = b"i100.2e";
        let b = BencodeNumber::from_bencode(a).unwrap();
        assert_eq!(a.to_vec(), b.to_bencode());
        println!("Number encoding and decoding passed.");
    }

    #[test]
    fn bytes() {
        let a = bencode!("HELLO WORLD");
        let b = BencodeBytes::from_bencode(&a.to_bencode()).unwrap();
        assert_eq!(a.as_any().downcast_ref::<BencodeBytes>().unwrap(), &b);

        let a = b"11:HELLO WORLD";
        let b = BencodeBytes::from_bencode(a).unwrap();
        assert_eq!(a.to_vec(), b.to_bencode());
        println!("Byte encoding and decoding passed.");
    }

    #[test]
    fn nested_object() {
        let a = bencode!({
            "a": "HELLO WORLD",
            "b": 100.2,
            "c": {
                "d": "NEST",
                "e": 66
            }
        });
        let b = BencodeObject::from_bencode(&a.to_bencode()).unwrap();
        assert_eq!(a.as_any().downcast_ref::<BencodeObject>().unwrap(), &b);

        let a = b"d1:a11:HELLO WORLD1:bi100.2e1:cd1:d4:NEST1:ei66eee";
        let b = BencodeObject::from_bencode(a).unwrap();
        assert_eq!(a.to_vec(), b.to_bencode());
        println!("Object nesting encoding and decoding passed.");
    }

    #[test]
    fn nested_array() {
        let a = bencode!([
            "HELLO WORLD",
            100.2,
            [
                "NEST",
                66
            ]
        ]);
        let b = BencodeArray::from_bencode(&a.to_bencode()).unwrap();
        assert_eq!(a.as_any().downcast_ref::<BencodeArray>().unwrap(), &b);

        let a = b"l11:HELLO WORLDi100.2el4:NESTi66eee";
        let b = BencodeArray::from_bencode(a).unwrap();
        assert_eq!(a.to_vec(), b.to_bencode());
        println!("Array nesting encoding and decoding passed.");
    }
}