btt 0.5.0

Binary to text encodings
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

use std::hash::BuildHasher;

use btt::{
	Base64, Base64Unpadded, Base64UrlPadded, Base64UrlUnpadded, DynEncoder, HexLower, HexUpper, Z85
};

#[test]
fn hex_lower() {
	random(&HexLower);
}

#[test]
fn hex_upper() {
	random(&HexUpper);
}

#[test]
fn base64() {
	random(&Base64);
}

#[test]
fn base64_unpadded() {
	random(&Base64Unpadded);
}

#[test]
fn base64_url_unpadded() {
	random(&Base64UrlUnpadded);
}

#[test]
fn base64_url_padded() {
	random(&Base64UrlPadded);
}

#[test]
fn base85() {
	random(&Z85);
}

fn random(encoder: &dyn DynEncoder) {
	fn check(encoder: &dyn DynEncoder, data: &[u8]) {
		let Some(encoded_len) = encoder.encoded_len(data.len()) else { return };
		let encoded = encoder.encode_string(data).unwrap();
		assert_eq!(encoded.len(), encoded_len);
		assert_eq!(encoder.decoded_len(encoded.as_bytes()).unwrap(), data.len());
		assert_eq!(encoder.decode_vec(encoded.as_bytes()).unwrap(), data);
	}

	let mut rng = std::collections::hash_map::RandomState::new().hash_one(0);
	let mut rng = move || {
		rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1);
		rng.rotate_left(8) as u8
	};

	let mut buf = [0; 1 << 10];
	buf.iter_mut().for_each(|b| *b = rng());

	for len in 0..buf.len() {
		check(encoder, &buf[..len]);
	}
}