use crate::constants::{
DP_SIGNAL_BASE, FILL_SIGNAL_BASE, FUTURE_SIGNAL_BASE, MAX_DP_SEGMENT_CHARS, MAX_FILL_BYTES,
MAX_TAIL_ZEROS, TAIL_SIGNAL_BASE,
};
use crate::digits::value_to_group;
use crate::{decode, DecodeError};
fn dp_signal(profile: u64, mask: u64, length: u64) -> String {
value_to_group(DP_SIGNAL_BASE + ((profile << 24) | (mask << 11) | (length - 1)))
}
fn fill_signal(byte: u64, length: u64) -> String {
value_to_group(FILL_SIGNAL_BASE + ((byte << 11) | (length - 1)))
}
#[test]
fn invalid_character_outside_alphabet_n() {
let err = decode("abc|").unwrap_err();
assert!(matches!(err, DecodeError::InvalidCharacter { character: '|', .. }), "{err:?}");
let err = decode("abc|e").unwrap_err();
assert!(matches!(err, DecodeError::InvalidCharacter { character: '|', .. }), "{err:?}");
let err = decode("abcdé").unwrap_err();
assert!(matches!(err, DecodeError::InvalidCharacter { character: 'é', .. }), "{err:?}");
}
#[test]
fn dp_signal_declared_length_overruns_available_input() {
let data: Vec<u8> = (0..40u8).map(|i| b'a' + (i % 26)).collect();
let encoded = crate::encode(&data);
assert!(encoded.len() > 5, "expected a DP signal + data, got {encoded:?}");
let truncated = &encoded[..encoded.len() - 3];
let err = decode(truncated).unwrap_err();
assert!(matches!(err, DecodeError::UnexpectedEndOfStream), "{err:?}");
}
#[test]
fn a_truncated_segment_with_a_bad_character_reports_the_truncation() {
let data: Vec<u8> = (0..40u8).map(|i| b'a' + (i % 26)).collect();
let encoded = crate::encode(&data);
let mut truncated: String = encoded[..encoded.len() - 3].to_string();
let at = truncated.len() - 4;
truncated.replace_range(at..at + 1, "|");
let err = decode(&truncated).unwrap_err();
assert!(
matches!(err, DecodeError::UnexpectedEndOfStream),
"the declared length is checked before the characters that arrived: {err:?}"
);
}
#[test]
fn length_field_is_biased_by_one() {
assert_eq!(decode(&format!("{}a", dp_signal(0, 0, 1))).unwrap(), b"a");
let err = decode(&dp_signal(0, 0, 1)).unwrap_err();
assert!(matches!(err, DecodeError::UnexpectedEndOfStream), "{err:?}");
assert_eq!(decode(&fill_signal(0x41, 1)).unwrap(), b"A");
}
#[test]
fn future_signal_space_is_rejected() {
let encoded = value_to_group(FUTURE_SIGNAL_BASE);
let err = decode(&format!("{}{}", encoded, "a".repeat(2048))).unwrap_err();
match err {
DecodeError::UndefinedSignal { value } => assert_eq!(value, FUTURE_SIGNAL_BASE),
other => panic!("expected UndefinedSignal, got {other:?}"),
}
let err = decode("#####").unwrap_err();
assert!(matches!(err, DecodeError::UndefinedSignal { .. }), "{err:?}");
}
#[test]
fn the_signal_range_boundaries_are_where_the_spec_puts_them() {
let last_dp = FILL_SIGNAL_BASE - 1;
assert_eq!(last_dp, DP_SIGNAL_BASE + (1 << 27) - 1);
let data = "a".repeat(MAX_DP_SEGMENT_CHARS);
let decoded = decode(&format!("{}{}", value_to_group(last_dp), data)).unwrap();
assert_eq!(decoded.len(), MAX_DP_SEGMENT_CHARS);
let last_fill = TAIL_SIGNAL_BASE - 1;
let decoded = decode(&value_to_group(last_fill)).unwrap();
assert_eq!(decoded, vec![0xffu8; MAX_FILL_BYTES]);
let decoded = decode(&value_to_group(FILL_SIGNAL_BASE)).unwrap();
assert_eq!(decoded, vec![0u8]);
let decoded = decode(&value_to_group(TAIL_SIGNAL_BASE)).unwrap();
assert_eq!(decoded, vec![0u8; 3]);
let decoded = decode(&value_to_group(FUTURE_SIGNAL_BASE - 1)).unwrap();
let mut expected = vec![0xffu8; 2];
expected.extend(std::iter::repeat_n(0u8, MAX_TAIL_ZEROS));
assert_eq!(decoded, expected);
}
#[test]
fn every_profile_identifier_decodes() {
for p in 0..8u64 {
let body = "^@%$?!~#abcdefghijkl";
let encoded = format!("{}{}", dp_signal(p, 0x1FFF, body.len() as u64), body);
let decoded = decode(&encoded).unwrap_or_else(|e| panic!("profile {p}: {e:?}"));
assert_eq!(decoded.len(), body.len(), "profile {p} changed the length");
}
}
#[test]
fn invalid_single_character_trailing_group() {
let err = decode("a").unwrap_err();
assert!(matches!(err, DecodeError::InvalidFinalBlock { length: 1 }), "{err:?}");
let mut encoded = crate::encode(&[1u8, 2, 3, 4]);
encoded.push('a');
let err = decode(&encoded).unwrap_err();
assert!(matches!(err, DecodeError::InvalidFinalBlock { length: 1 }), "{err:?}");
}
#[test]
fn final_block_must_be_canonical() {
for bytes in [vec![0x61u8], vec![0x61, 0x62], vec![0xff, 0xff, 0xff]] {
let canonical = crate::encode(&bytes);
assert_eq!(decode(&canonical).unwrap(), bytes);
let mut chars: Vec<char> = canonical.chars().collect();
let last = chars.len() - 1;
let v = crate::alphabet::char_to_value(chars[last]).unwrap();
if v < 84 {
chars[last] = crate::alphabet::value_to_char(v + 1);
let alias: String = chars.into_iter().collect();
let err = decode(&alias)
.map(|d| format!("accepted, decoding to {d:?}"))
.unwrap_err()
.to_string();
assert!(err.contains("final block"), "{alias:?}: {err}");
}
}
}
#[test]
fn partial_block_value_out_of_range() {
for over_limit in ["##", "###", "####"] {
let err = decode(over_limit).unwrap_err();
assert!(
matches!(err, DecodeError::InvalidFinalBlock { .. }),
"{over_limit}: {err:?}"
);
}
}
#[test]
fn decode_never_panics_on_arbitrary_short_garbage() {
let cases = [
"~",
"~~~",
"12345~",
"\u{0}",
" ",
"#####",
"$$$$$",
"vpA.2f!@~",
&dp_signal(7, 0x1FFF, 2048),
&format!("{}xxxxx", dp_signal(3, 0, 40)),
&format!("{}~", fill_signal(0, 2048)),
];
for c in cases {
let _ = decode(c); }
}
#[test]
fn unexpected_end_of_stream_mid_five_char_group_is_not_a_panic() {
for s in ["ab", "abc", "abcd"] {
let _ = decode(s);
}
}
#[test]
fn fill_expansion_stays_bounded() {
let signals = super::cases(2000);
let stream = fill_signal(0x5a, MAX_FILL_BYTES as u64).repeat(signals);
let decoded = decode(&stream).unwrap();
assert_eq!(decoded.len(), signals * MAX_FILL_BYTES);
assert!(decoded.iter().all(|&b| b == 0x5a));
assert_eq!(decoded.len() / stream.len(), MAX_FILL_BYTES / 5);
}