use super::{
KeyRule, STOP, Template, TemplateError, TemplateKind, TemplateRefusal, Token, Var, check,
check_member, check_member_template, check_prefixed, check_template, cut_tail, safe, safe_into,
tokens,
};
fn expanded<'v>(t: &Template, value: impl Fn(Var) -> &'v [u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(STOP);
let at = out.as_ptr();
let _ = t.expand(value, &mut out);
assert_eq!(out.as_ptr(), at, "the expansion grew its buffer");
out
}
#[test]
fn the_stop_tells_a_cut_code_point_from_an_invalid_byte() {
let t = Template::parse("{atlas}", TemplateKind::AtlasJson).unwrap();
let mut v = vec![b'a'; 1023];
v.extend("\u{1f600}".as_bytes());
let mut out = Vec::with_capacity(STOP);
assert_eq!(t.expand(|_| &v, &mut out), 2);
v.truncate(1025);
v.push(b'z');
assert_eq!(t.expand(|_| &v, &mut out), 0);
let lit = format!("{}\u{e9}x", "b".repeat(1024));
let t = Template::parse(&lit, TemplateKind::AtlasJson).unwrap();
assert_eq!(t.expand(|_| b"", &mut out), 1);
assert_eq!(cut_tail(b"abc", 2), 0);
assert_eq!(cut_tail("a\u{e9}".as_bytes(), 3), 0);
assert_eq!(cut_tail(b"a\xff\xff", 2), 0);
let t = Template::parse("{atlas}{sprite}", TemplateKind::AtlasSprite).unwrap();
let mut atlas = [b"a/".repeat(511), b"x".to_vec()].concat();
atlas.push(0xF0);
let sprite = b"\x9f\x98\x80z";
let value = |v: Var| match v {
Var::Atlas => atlas.as_slice(),
_ => sprite.as_slice(),
};
assert_eq!(t.expand(value, &mut out), 2);
atlas.push(0x9F);
let value = |v: Var| match v {
Var::Atlas => atlas.as_slice(),
_ => &sprite[1..],
};
assert_eq!(t.expand(value, &mut out), 2);
let t = Template::parse("{atlas}{safe_sprite}", TemplateKind::AtlasSprite).unwrap();
let value = |v: Var| match v {
Var::Atlas => atlas.as_slice(),
_ => sprite.as_slice(),
};
assert_eq!(t.expand(value, &mut out), 0);
}
#[test]
fn an_expansion_stops_one_byte_past_the_bound() {
let t = Template::parse("a/{atlas}/b", TemplateKind::AtlasJson).unwrap();
let big = vec![b'x'; 5000];
assert_eq!(expanded(&t, |_| &big).len(), STOP);
assert_eq!(expanded(&t, |_| b"n"), b"a/n/b");
let t = Template::parse("{safe_atlas}", TemplateKind::AtlasJson).unwrap();
let huge = [b"..".as_slice(), &vec![b'a'; 1 << 24], b"..."].concat();
assert_eq!(expanded(&t, |_| &huge), vec![b'a'; STOP]);
}
#[test]
fn safe_into_is_safes_prefix() {
let cases: [&[u8]; 9] = [
b"..x..",
b"a..b...",
b"...",
b"",
b"a b/c",
"\u{e4}tlas".as_bytes(),
b"bad\xff\xfe..",
b"\xe2\x82.",
b".a.",
];
for bytes in cases {
let whole = safe(bytes);
for room in 0..=whole.len() + 1 {
let mut out = b"pre".to_vec();
safe_into(bytes, room, &mut out);
let want = &whole.as_bytes()[..room.min(whole.len())];
assert_eq!(&out[3..], want, "{bytes:?} at {room}");
}
}
}
#[test]
fn a_key_past_the_bound_is_decided_on_its_first_1025_bytes() {
let at = |n: usize, tail: &[u8]| {
let mut k = vec![b'a'; n];
for (i, b) in k.iter_mut().enumerate() {
if i % 200 == 199 {
*b = b'/';
}
}
k.extend_from_slice(tail);
check(&k).unwrap_err()
};
assert_eq!(
at(1001, b"\tzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"),
KeyRule::ControlChar
);
assert_eq!(at(1025, b"\t"), KeyRule::TooLong);
assert_eq!(at(1024, b"/"), KeyRule::TooLong);
assert_eq!(at(1023, b"/."), KeyRule::TooLong);
assert_eq!(at(1024, "\u{e9}".as_bytes()), KeyRule::TooLong);
assert_eq!(
at(1001, b"/../aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
KeyRule::DotSegment
);
let mut seg = vec![b'a'; 300];
seg.extend(vec![b'b'; 900]);
assert_eq!(check(&seg).unwrap_err(), KeyRule::SegmentTooLong);
}
#[test]
fn a_cut_code_point_still_counts_in_its_segments_length() {
let key = |head: &[u8], x: usize| {
let mut k = head.to_vec();
k.extend(b"a/".repeat(383));
k.extend(vec![b'x'; x]);
k.extend("\u{1f600}".as_bytes());
k
};
let long = key(b"aa/", 254);
assert_eq!(long.len(), 1027);
assert_eq!(check(&long), Err(KeyRule::SegmentTooLong));
assert_eq!(check_member(&long), Err(KeyRule::SegmentTooLong));
let short = key(b"aaa/", 253);
assert_eq!(check(&short), Err(KeyRule::TooLong));
assert_eq!(check_member(&short), Err(KeyRule::TooLong));
}
#[test]
fn a_key_is_checked_then_checked_again_after_the_prefix() {
let mut scratch = Vec::with_capacity(STOP);
let at = scratch.as_ptr();
assert_eq!(
check_prefixed(b"a.png", "out/", &mut scratch).unwrap(),
"a.png"
);
assert_eq!(
check_prefixed(b"a.png", "_unityrs/", &mut scratch).unwrap_err(),
KeyRule::ReservedPrefix
);
let long = format!("{}c", "ab/".repeat(333));
assert_eq!(
check_prefixed(long.as_bytes(), &"p/".repeat(20), &mut scratch).unwrap_err(),
KeyRule::TooLong
);
assert_eq!(scratch.as_ptr(), at, "the check grew its buffer");
assert_eq!(
check_prefixed(b"a//b", "_unityrs/", &mut scratch).unwrap_err(),
KeyRule::EmptySegment
);
}
#[test]
fn a_member_path_takes_every_rule_but_the_reserved_ones() {
assert_eq!(check_member(b"_unityrs/a").unwrap(), "_unityrs/a");
assert_eq!(
check_member(b"a/.unityrs-tmp-1").unwrap(),
"a/.unityrs-tmp-1"
);
assert_eq!(check_member(b"a/").unwrap_err(), KeyRule::TrailingSlash);
}
#[test]
fn safe_replaces_per_code_point_and_strips_dots() {
assert_eq!(safe("\u{e4}tlas".as_bytes()), "_tlas");
assert_eq!(safe(b"a b/c"), "a_b_c");
assert_eq!(safe(b"..x.."), "x");
assert_eq!(safe(b"..."), "unnamed");
assert_eq!(safe(b""), "unnamed");
assert_eq!(safe(b"bad\xff\xfe"), "bad__");
assert_eq!(safe(b"\xe2\x82"), "__");
assert_eq!(safe("\u{7cbe}\u{7075}".as_bytes()), "__");
assert_eq!(safe(b"a..b."), "a..b");
}
#[test]
fn templates_parse_braces_and_refuse_unknown_variables() {
let t = Template::parse("{{x}}/{atlas}-{sprite}.png", TemplateKind::AtlasSprite).unwrap();
let key = expanded(&t, |v| match v {
Var::Atlas => b"a",
Var::Sprite => b"s",
_ => b"",
});
assert_eq!(key, b"{x}/a-s.png");
assert_eq!(
Template::parse("{nope}", TemplateKind::AtlasJson),
Err(TemplateError::Unknown("nope".to_owned()))
);
assert_eq!(
Template::parse("{sprite}.json", TemplateKind::AtlasJson),
Err(TemplateError::NotAllowed("sprite".to_owned()))
);
assert_eq!(
Template::parse("{name}", TemplateKind::AtlasSprite),
Err(TemplateError::NotAllowed("name".to_owned()))
);
assert_eq!(
Template::parse("a}", TemplateKind::Texture),
Err(TemplateError::Brace(1))
);
assert_eq!(
Template::parse("a{b", TemplateKind::Texture),
Err(TemplateError::Brace(1))
);
assert_eq!(
Template::parse("", TemplateKind::Texture),
Err(TemplateError::Empty)
);
assert!(Template::parse("{type}/{safe_name}_{path_id}", TemplateKind::Texture).is_ok());
let sprite = "{safe_input}/{type}/{name}-{safe_name}_{path_id}.png";
assert!(Template::parse(sprite, TemplateKind::Sprite).is_ok());
for name in ["atlas", "safe_atlas", "sprite", "safe_sprite"] {
assert_eq!(
Template::parse(&format!("{{{name}}}"), TemplateKind::Sprite),
Err(TemplateError::NotAllowed(name.to_owned()))
);
}
assert_eq!(
Template::parse("{name}", TemplateKind::AtlasJson),
Err(TemplateError::NotAllowed("name".to_owned()))
);
assert_eq!(TemplateKind::Sprite.name(), "sprite");
}
#[test]
fn the_first_rule_broken_names_the_refusal() {
let bad = |k: &[u8]| check(k).unwrap_err();
assert_eq!(bad(b""), KeyRule::Empty);
assert_eq!(bad(b"a\xff/"), KeyRule::NotUtf8);
assert_eq!(bad(b"/a\tb"), KeyRule::ControlChar);
assert_eq!(bad(b"a\x7f"), KeyRule::ControlChar);
assert_eq!(bad(b"/a//"), KeyRule::LeadingSlash);
assert_eq!(bad(b"a//"), KeyRule::TrailingSlash);
assert_eq!(bad(b"a//b"), KeyRule::EmptySegment);
assert_eq!(bad(b"a/../b"), KeyRule::DotSegment);
assert_eq!(bad(b"./b"), KeyRule::DotSegment);
assert_eq!(bad(&[b'x'; 256]), KeyRule::SegmentTooLong);
let long: Vec<u8> = [b"a/".as_slice(); 513].concat();
assert_eq!(bad(&long[..1025]), KeyRule::TooLong);
assert_eq!(bad(b"_unityrs"), KeyRule::ReservedPrefix);
assert_eq!(bad(b"_unityrs/x"), KeyRule::ReservedPrefix);
assert_eq!(bad(b"a/.unityrs-tmp-1"), KeyRule::ReservedName);
assert_eq!(check(b"_unityrsx/a.png").unwrap(), "_unityrsx/a.png");
assert_eq!(check(b"..a/b.").unwrap(), "..a/b.");
}
#[test]
fn the_sprites_kind_takes_the_object_variables() {
for t in [
"{type}/{name}.png",
"{safe_name}_{path_id}",
"{input}/{safe_input}",
] {
assert!(Template::parse(t, TemplateKind::Sprite).is_ok(), "{t}");
}
for (t, name) in [("{atlas}", "atlas"), ("{safe_sprite}", "safe_sprite")] {
assert_eq!(
Template::parse(t, TemplateKind::Sprite),
Err(TemplateError::NotAllowed(name.to_owned()))
);
}
}
#[test]
fn tokens_read_the_grammar_once() {
let got: Vec<_> = tokens("a{{b}}/{name}c", TemplateKind::Texture).collect();
assert_eq!(
got,
[
Ok(Token::Lit("a")),
Ok(Token::Lit("{")),
Ok(Token::Lit("b")),
Ok(Token::Lit("}")),
Ok(Token::Lit("/")),
Ok(Token::Var(Var::Name)),
Ok(Token::Lit("c")),
]
);
let got: Vec<_> = tokens("a}b{name}", TemplateKind::Texture).collect();
assert_eq!(got, [Ok(Token::Lit("a")), Err(TemplateError::Brace(1))]);
assert_eq!(tokens("", TemplateKind::Texture).count(), 0);
}
fn literal_rule(text: &str) -> Option<KeyRule> {
match check_template(text, TemplateKind::Texture) {
Ok(()) => None,
Err(TemplateRefusal::Literal(r)) => Some(r),
Err(e) => panic!("{text}: {e}"),
}
}
#[test]
fn a_literal_part_that_breaks_a_key_rule_is_refused() {
let long = "x".repeat(256);
let cases: &[(&str, Option<KeyRule>)] = &[
("{input}/{name}.png", None),
("/{name}", Some(KeyRule::LeadingSlash)),
("{name}/", Some(KeyRule::TrailingSlash)),
("a/{name}/", Some(KeyRule::TrailingSlash)),
("a//{name}", Some(KeyRule::EmptySegment)),
("{input}//{name}", Some(KeyRule::EmptySegment)),
("a/./{name}", Some(KeyRule::DotSegment)),
("{name}/..", Some(KeyRule::DotSegment)),
("{name}/.../x", None),
("{name}/.x", None),
("_unityrs", Some(KeyRule::ReservedPrefix)),
("_unityrs/{name}", Some(KeyRule::ReservedPrefix)),
("_unityrs{name}", None),
("{name}_unityrs/x", None),
("{input}/.unityrs-tmp-a", Some(KeyRule::ReservedName)),
("{input}/.unityrs-tmp-{name}", None),
("{input}/.unityrs-tm", None),
("{input}/.{name}", None),
("{input}/{{}}", None),
("{input}/a\u{1}", None),
("/a//./_x/", Some(KeyRule::LeadingSlash)),
("a//./", Some(KeyRule::TrailingSlash)),
];
for (text, want) in cases {
assert_eq!(literal_rule(text), *want, "{text}");
}
let t = format!("{{input}}/{long}");
assert_eq!(literal_rule(&t), Some(KeyRule::SegmentTooLong));
let t = format!("{{input}}/{}", &long[1..]);
assert_eq!(literal_rule(&t), None);
let t = format!("{{input}}/{}{{{{}}}}", &long[3..]);
assert_eq!(literal_rule(&t), None);
let t = format!("{{input}}/{}{{{{}}}}", &long[2..]);
assert_eq!(literal_rule(&t), Some(KeyRule::SegmentTooLong));
assert_eq!(
check_template("{nope}", TemplateKind::Texture),
Err(TemplateRefusal::Parse(TemplateError::Unknown(
"nope".into()
)))
);
assert_eq!(
check_template("", TemplateKind::Texture),
Err(TemplateRefusal::Parse(TemplateError::Empty))
);
}
#[test]
fn a_member_template_skips_the_reserved_rules() {
for t in ["_unityrs/{atlas}", "_unityrs", "{atlas}/.unityrs-tmp-x"] {
assert!(check_template(t, TemplateKind::AtlasJson).is_err(), "{t}");
assert_eq!(
check_member_template(t, TemplateKind::AtlasJson),
Ok(()),
"{t}"
);
}
assert_eq!(
check_member_template("{atlas}//x", TemplateKind::AtlasJson),
Err(TemplateRefusal::Literal(KeyRule::EmptySegment))
);
}
#[test]
fn a_literal_template_is_checked_as_its_key() {
let parts = [
"a",
"/",
".",
"..",
"_unityrs",
".unityrs-tmp-",
"x\u{1}",
"{{",
"}}",
];
let checked = [
KeyRule::LeadingSlash,
KeyRule::TrailingSlash,
KeyRule::EmptySegment,
KeyRule::DotSegment,
KeyRule::SegmentTooLong,
KeyRule::ReservedPrefix,
KeyRule::ReservedName,
];
let mut n = 0;
for a in parts {
for b in parts {
for c in parts {
let text = format!("{a}{b}{c}");
let key = text.replace("{{", "{").replace("}}", "}");
let plain = key.replace('\u{1}', "");
let want = check(plain.as_bytes())
.err()
.filter(|r| checked.contains(r));
assert_eq!(literal_rule(&text), want, "{text:?}");
n += 1;
}
}
}
assert_eq!(n, 729);
}