use rand::rngs::StdRng;
use rand::{RngExt, SeedableRng};
use crate::alphabet::{ALPHABET_N, NUM_PROFILES, PROFILES, RSET_ASCII, RSET_LEN};
use crate::constants::{
MAX_DP_ANALYSIS_BYTES, MAX_FILL_BYTES, MIN_FILL_BYTES, MIN_PASSTHROUGH_BYTES,
};
use crate::{decode, encode};
fn roundtrip(data: &[u8]) {
let encoded = encode(data);
let decoded = decode(&encoded)
.unwrap_or_else(|e| panic!("decode failed: {e:?} (encoded = {encoded:?})"));
assert_eq!(decoded, data, "roundtrip mismatch; encoded = {encoded:?}");
}
fn varied(len: usize) -> Vec<u8> {
(0..len).map(|i| b'a' + (i % 26) as u8).collect()
}
#[test]
fn empty_input() {
assert_eq!(encode(&[]), "");
assert_eq!(decode("").unwrap(), Vec::<u8>::new());
}
#[test]
fn lengths_one_through_four() {
for len in 1..=4usize {
let data: Vec<u8> = (0..len as u8).map(|i| b'a' + i).collect();
roundtrip(&data);
}
}
#[test]
fn below_min_passthrough_bytes_uses_block_mode() {
let data = varied(19);
let encoded = encode(&data);
assert_eq!(encoded.len(), 24, "encoded = {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), data);
}
#[test]
fn exactly_min_passthrough_bytes_uses_dp_mode() {
let data = varied(MIN_PASSTHROUGH_BYTES);
let encoded = encode(&data);
assert_eq!(encoded.len(), 5 + MIN_PASSTHROUGH_BYTES, "encoded = {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), data);
}
#[test]
fn one_above_min_passthrough_bytes_uses_dp_mode() {
let data = varied(21);
let encoded = encode(&data);
assert_eq!(encoded.len(), 26, "encoded = {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), data);
}
#[test]
fn analysis_window_bounds_a_segment() {
let exact = varied(MAX_DP_ANALYSIS_BYTES);
let encoded = encode(&exact);
assert_eq!(encoded.len(), MAX_DP_ANALYSIS_BYTES + 5, "encoded len");
assert_eq!(decode(&encoded).unwrap(), exact);
let over = varied(MAX_DP_ANALYSIS_BYTES + 1);
let encoded = encode(&over);
assert_eq!(encoded.len(), MAX_DP_ANALYSIS_BYTES + 5 + 2, "encoded len");
assert_eq!(decode(&encoded).unwrap(), over);
}
#[test]
fn long_run_uses_one_signal_per_window() {
let data = varied(3 * MAX_DP_ANALYSIS_BYTES + 100);
let encoded = encode(&data);
assert_eq!(encoded.len(), data.len() + 4 * 5, "encoded = {}", encoded.len());
assert_eq!(decode(&encoded).unwrap(), data);
}
#[test]
fn fill_threshold_and_cap() {
for byte in [0u8, b' ', b'a', 0xff] {
let short = vec![byte; MIN_FILL_BYTES - 1];
let encoded = encode(&short);
assert_eq!(encoded.len(), 5, "{byte:#04x}: {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), short);
let at = vec![byte; MIN_FILL_BYTES];
let encoded = encode(&at);
assert_eq!(encoded.len(), 5, "{byte:#04x}: {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), at);
let cap = vec![byte; MAX_FILL_BYTES];
let encoded = encode(&cap);
assert_eq!(encoded.len(), 5, "{byte:#04x}: {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), cap);
let over = vec![byte; MAX_FILL_BYTES + 1];
let encoded = encode(&over);
assert_eq!(encoded.len(), 7, "{byte:#04x}: {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), over);
let two = vec![byte; 2 * MAX_FILL_BYTES];
assert_eq!(encode(&two).len(), 10);
assert_eq!(decode(&encode(&two)).unwrap(), two);
}
}
#[test]
fn fill_interrupts_text() {
let mut data = Vec::new();
data.extend_from_slice(&varied(40));
data.extend(std::iter::repeat_n(b'=', 300));
data.extend_from_slice(&varied(40));
let encoded = encode(&data);
assert_eq!(encoded.len(), 5 + 40 + 5 + 5 + 40, "encoded = {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), data);
}
#[test]
fn fill_dp_and_block_transitions() {
let mut data = Vec::new();
data.extend(std::iter::repeat_n(0u8, 64));
data.extend_from_slice(b"{\"name\": \"Ada Lovelace\", \"id\": 42}");
data.extend(std::iter::repeat_n(0xffu8, 7));
data.extend_from_slice(&[0x89, 0x50, 0x4e, 0x47, 0x0d, 0x1a, 0x0a]);
data.extend(std::iter::repeat_n(b' ', 2050));
data.extend_from_slice(b"trailing text that is long enough for a segment");
roundtrip(&data);
}
#[test]
fn all_byte_values_present() {
let data: Vec<u8> = (0u16..=255).map(|b| b as u8).collect();
roundtrip(&data);
let mut data2 = Vec::new();
for _ in 0..8 {
data2.extend((0u16..=255).map(|b| b as u8));
}
roundtrip(&data2);
}
#[test]
fn unrepresentable_first_byte_falls_back_to_small_block() {
let mut data = vec![0xFFu8, 0x00, 0x01, 0x02, 0x03];
data.extend(varied(30));
roundtrip(&data);
roundtrip(&[0xFFu8]);
roundtrip(&[0xFFu8, 0xFE, 0xFD]);
}
#[test]
fn every_rset_character_round_trips() {
for &r in RSET_ASCII.iter() {
let mut data = Vec::new();
while data.len() < 3 * MIN_PASSTHROUGH_BYTES {
data.extend_from_slice(b"word");
data.push(r);
}
roundtrip(&data);
}
}
#[test]
fn literal_donor_characters_round_trip() {
for donor in all_donors() {
let mut data = varied(25);
data.push(b' ');
data.push(donor);
data.push(b' ');
data.extend(varied(25));
roundtrip(&data);
}
}
#[test]
fn all_rset_characters_at_once_is_one_dp_segment() {
let mut data = Vec::new();
for _ in 0..3 {
data.extend_from_slice(&RSET_ASCII);
}
let encoded = encode(&data);
assert_eq!(encoded.len(), data.len() + 5, "encoded = {encoded:?}");
assert_eq!(decode(&encoded).unwrap(), data);
let mut mixed = data.clone();
mixed.push(b'-');
mixed.extend_from_slice(&RSET_ASCII);
roundtrip(&mixed);
}
#[test]
fn output_is_always_alphabet_n() {
let samples: Vec<Vec<u8>> = vec![
(0u16..=255).map(|b| b as u8).collect(),
b"Hello, World!\r\n\t".repeat(10),
br#"{"a": "b", "c": [1, 2]}"#.repeat(5),
b"<p>x & y</p>".repeat(5),
RSET_ASCII.repeat(5),
ALPHABET_N.repeat(4),
vec![0u8; 5000],
];
for data in samples {
let encoded = encode(&data);
assert!(
encoded.bytes().all(|c| ALPHABET_N.contains(&c)),
"encoder emitted a character outside Alphabet-N: {encoded:?}"
);
}
}
pub(crate) fn all_donors() -> Vec<u8> {
let mut v: Vec<u8> = PROFILES.iter().flat_map(|p| p.iter().copied()).collect();
v.sort_unstable();
v.dedup();
v
}
#[test]
fn output_fits_the_capacity_the_encoder_reserves() {
let capacity = |n: usize| n + n / 4 + 16;
let mut rng = StdRng::seed_from_u64(0x0CA9_AC17);
let check = |data: &[u8], what: &str| {
let encoded = crate::encode(data);
assert!(
encoded.len() <= capacity(data.len()),
"{what}: {} bytes encoded to {} characters, over the {} reserved",
data.len(),
encoded.len(),
capacity(data.len())
);
};
for len in 0..super::cases(300) {
check(&vec![0u8; len], "zeros");
check(&vec![b'a'; len], "one repeated character");
let random: Vec<u8> = (0..len).map(|_| rng.random::<u8>()).collect();
check(&random, "random bytes");
let text: Vec<u8> = (0..len).map(|i| b"the quick brown fox, 0123456789 "[i % 32]).collect();
check(&text, "text");
}
let long: &[usize] =
if cfg!(miri) { &[1000, 2047, 2048, 2049] } else { &[1000, 2047, 2048, 2049, 5000, 100_000] };
for &len in long {
let mixed: Vec<u8> = (0..len)
.map(|i| match i % 5 {
0 => 0,
1 => rng.random::<u8>(),
_ => b"text and text and text "[i % 23],
})
.collect();
check(&mixed, "mixed");
}
}
#[test]
fn there_are_exactly_eight_profiles_of_thirteen_distinct_donors() {
assert_eq!(PROFILES.len(), NUM_PROFILES);
assert_eq!(NUM_PROFILES, 8);
assert_eq!(RSET_ASCII.len(), RSET_LEN);
for profile in PROFILES.iter() {
assert_eq!(profile.len(), RSET_LEN);
for (i, &c) in profile.iter().enumerate() {
assert!(ALPHABET_N.contains(&c), "donor outside Alphabet-N");
assert!(!profile[..i].contains(&c), "duplicate donor in a profile");
}
}
for &r in RSET_ASCII.iter() {
assert!(!ALPHABET_N.contains(&r), "R-Set character in Alphabet-N");
}
}