binarytext 0.1.2

Binary-to-text encoders / decoders
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
134
135

//! This crate provides different encoders and some of their variants, like Base64 or Base32.
//! All of them implement the trait BinaryText in the module binarytext and share a common
//! interface.
//!
//! Furthermore error types can be found in the mod error.
//! Functions for handling encoding / decoding of byte streams from a source to a destination, e.g.
//! input string decoded to stdout, are provided in the module stream.

pub mod base16;
pub mod base32;
pub mod base45;
pub mod base64;
pub mod base85;
pub mod binarytext;
pub mod error;
pub mod int;
pub mod stream;

#[cfg(test)]
mod tests {
    use crate::base16::Base16;
    use crate::base32::Base32;
    use crate::base45::Base45;
    use crate::base64::Base64;
    use crate::base85::Base85;
    use crate::binarytext::BinaryText;
    use crate::int::IntEncoder;

    fn compare<B: BinaryText>(b: &B, dec: &str, enc: &str) {
        assert_eq!(b.decode_from_str(enc).unwrap(), dec.to_string());
        assert_eq!(b.encode_from_str(dec).unwrap(), enc.to_string());
    }

    fn compare_int<B: BinaryText>(b: &B, int: u64, s: &str) {
        assert_eq!(b.decode_u64(s.as_bytes()).unwrap(), int);
        assert_eq!(b.encode_u64(int).unwrap(), s.to_string());
        let int128 = int as u128;
        assert_eq!(b.decode_u128(s.as_bytes()).unwrap(), int128);
        assert_eq!(b.encode_u128(int128).unwrap(), s.to_string());
    }

    #[test]
    fn base16() {
        let b = Base16::new();
        compare(&b, "", "");
        compare(&b, "f", "66");
        compare(&b, "fo", "666F");
        compare(&b, "foo", "666F6F");
        compare(&b, "foob", "666F6F62");
        compare(&b, "fooba", "666F6F6261");
        compare(&b, "foobar", "666F6F626172");
    }

    #[test]
    fn base32() {
        let b = Base32::new();
        compare(&b, "", "");
        compare(&b, "f", "MY======");
        compare(&b, "fo", "MZXQ====");
        compare(&b, "foo", "MZXW6===");
        compare(&b, "foob", "MZXW6YQ=");
        compare(&b, "fooba", "MZXW6YTB");
        compare(&b, "foobar", "MZXW6YTBOI======");
    }

    #[test]
    fn base32hex() {
        let b = Base32::base32hex();
        compare(&b, "", "");
        compare(&b, "f", "CO======");
        compare(&b, "fo", "CPNG====");
        compare(&b, "foo", "CPNMU===");
        compare(&b, "foob", "CPNMUOG=");
        compare(&b, "fooba", "CPNMUOJ1");
        compare(&b, "foobar", "CPNMUOJ1E8======");
    }

    #[test]
    fn base36() {
        let b = IntEncoder::base36();
        compare_int(&b, 0u64, "");
        compare_int(&b, 123u64, "3F");
        compare_int(&b, 926192u64, "JUNK");
        compare_int(&b, 9223372036854775807u64, "1Y2P0IJ32E8E7");
        compare_int(&b, 18537u64, "EAX");
        compare(&b, "", "");
        compare(&b, "Hi", "EAX");
    }

    #[test]
    fn base45() {
        let b = Base45::new();
        //Examples taken from RFC 9285
        compare(&b, "", "");
        compare(&b, "AB", "BB8");
        compare(&b, "base-45", "UJCLQE7W581");
        compare(&b, "Hello!!", "%69 VD92EX0");
        compare(&b, "ietf!", "QED8WEX0");
    }

    #[test]
    fn base62() {
        let b = IntEncoder::base62();
        compare_int(&b, 0u64, "");
        compare_int(&b, 91574294826053u64, "Q0DRQksv");
        compare(&b, "SIMPLE", "Q0DRQksv");
    }

    #[test]
    fn base64() {
        let b = Base64::new();
        compare(&b, "", "");
        compare(&b, "f", "Zg==");
        compare(&b, "fo", "Zm8=");
        compare(&b, "foo", "Zm9v");
        compare(&b, "foob", "Zm9vYg==");
        compare(&b, "fooba", "Zm9vYmE=");
        compare(&b, "foobar", "Zm9vYmFy");
    }

    #[test]
    fn base85() {
        let b = Base85::new();
        // Examples taken from Wikipedia
        compare(&b, "", "");
        compare(&b, "Man ", "9jqo^");
        compare(&b, "sure", "F*2M7");
        compare(&b, ".", "/c");
        compare(
            &b,
            "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.",
            "9jqo^BlbD-BleB1DJ+*+F(f,q/0JhKF<GL>Cj@.4Gp$d7F!,L7@<6@)/0JDEF<G%<+EV:2F!,O<DJ+*.@<*K0@<6L(Df-\\0Ec5e;DffZ(EZee.Bl.9pF\"AGXBPCsi+DGm>@3BB/F*&OCAfu2/AKYi(DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF<G:8+EV:.+Cf>-FD5W8ARlolDIal(DId<j@<?3r@:F%a+D58'ATD4$Bl@l3De:,-DJs`8ARoFb/0JMK@qB4^F!,R<AKZ&-DfTqBG%G>uD.RTpAKYo'+CT/5+Cei#DII?(E,9)oF*2M7/c",
        );
    }
}