base45 3.2.0

Encoder/decoder for base45
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

use crate::*;
#[cfg(not(feature = "std"))]
use alloc::{string::String, vec};

#[test]
fn encode_ab() {
    assert_eq!(encode("AB"), "BB8")
}

#[test]
fn decode_fail() {
    assert!(decode(":::").is_err());
}

#[test]
fn decode_fail_out_of_range() {
    assert!(decode(":::").is_err());
}

#[test]
fn encode_hello() {
    assert_eq!(encode("Hello!!"), "%69 VD92EX0")
}

#[test]
fn encode_base45() {
    assert_eq!(encode("base-45"), "UJCLQE7W581")
}

#[test]
fn encode_long_string() {
    assert_eq!(
        encode("The quick brown fox jumps over the lazy dog"),
        "8UADZCKFEOEDJOD2KC54EM-DX.CH8FSKDQ$D.OE44E5$CS44+8DK44OEC3EFGVCD2",
    )
}

#[test]
fn encode_unicode() {
    assert_eq!(encode("foo © bar 𝌆 baz"), "X.C82EIROA44GECH74C-J1/GUJCW2")
}

#[test]
fn encode_emoji() {
    assert_eq!(encode("I ❤️  Rust"), "0B98TSD%K.ENY244JA QE")
}

#[test]
fn encode_ietf() {
    assert_eq!(encode("ietf!"), "QED8WEX0")
}

#[test]
fn decode_ab() {
    assert_eq!(String::from_utf8(decode("BB8").unwrap()).unwrap(), "AB")
}

#[test]
fn decode_hello() {
    assert_eq!(
        String::from_utf8(decode("%69 VD92EX0").unwrap()).unwrap(),
        "Hello!!"
    )
}

#[test]
fn decode_base45() {
    assert_eq!(
        String::from_utf8(decode("UJCLQE7W581").unwrap()).unwrap(),
        "base-45"
    )
}

#[test]
fn decode_ietf() {
    assert_eq!(
        String::from_utf8(decode("QED8WEX0").unwrap()).unwrap(),
        "ietf!"
    )
}

const QUICK_BROWN_FOX_ENC: &str =
    "8UADZCKFEOEDJOD2KC54EM-DX.CH8FSKDQ$D.OE44E5$CS44+8DK44OEC3EFGVCD2";
const QUICK_BROWN_FOX_DEC: &str = "The quick brown fox jumps over the lazy dog";
#[test]
fn decode_long_string() {
    assert_eq!(
        String::from_utf8(decode(QUICK_BROWN_FOX_ENC).unwrap()).unwrap(),
        QUICK_BROWN_FOX_DEC,
    )
}

#[test]
fn encode_hello_from_buffer() {
    assert_eq!(encode(vec![72, 101, 108, 108, 111, 33, 33]), "%69 VD92EX0")
}

#[test]
fn encode_full_bytes() {
    let s = encode(b"\xff\xff\xff\xff\xff\xff");
    assert_eq!(s, "FGWFGWFGW");
    let s = encode(b"\xff\xff\xff\xff\xff\xff\xff");
    assert_eq!(s, "FGWFGWFGWU5");
    let s = encode(b"\xff\xff\xff\xff\xff\xff\xff\xff");
    assert_eq!(s, "FGWFGWFGWFGW");
}
#[test]
fn decode_full_bytes() {
    let s = decode("FGWFGWFGW").unwrap();
    assert_eq!(s, b"\xff\xff\xff\xff\xff\xff");
    let s = decode("FGWFGWFGWU5").unwrap();
    assert_eq!(s, b"\xff\xff\xff\xff\xff\xff\xff");
    let s = decode("FGWFGWFGWFGW").unwrap();
    assert_eq!(s, b"\xff\xff\xff\xff\xff\xff\xff\xff");
}