#![forbid(unsafe_code)]
#![cfg(feature = "alloc")]
use safehtml::{
Identifier, SafeHtml, SafeHtmlBuilder, SafeHtmlStr, SliceWriter, disp, safe_html_cat,
safe_html_format, safe_html_format_to, safe_html_write,
};
#[test]
fn cat_works_under_forbid_unsafe_code() {
let html = safe_html_cat!(SafeHtml::from_constant("<b>"), "a & b", 42);
assert_eq!(html.as_str(), "<b>a & b42");
}
#[test]
fn format_named_escapes_arguments() {
let date = "2026-07-18";
let title = "Bob & <Alice> \"quoted\"";
let html = safe_html_format!(
r#"<input name="date" value="{date}" title="{t}">"#,
date = date,
t = title,
);
assert_eq!(
html.as_str(),
r#"<input name="date" value="2026-07-18" title="Bob & <Alice> "quoted"">"#
);
}
#[test]
fn format_named_safe_types_pass_verbatim() {
let inner = safe_html_cat!("x < y");
let id = Identifier::from_constant("row-1");
let html = safe_html_format!("<td id=\"{id}\">{body}</td>", id = id, body = inner);
assert_eq!(html.as_str(), "<td id=\"row-1\">x < y</td>");
}
#[test]
fn format_named_numbers_and_bools() {
let html = safe_html_format!("{a},{b},{c}", a = -5i32, b = 2.5f64, c = true);
assert_eq!(html.as_str(), "-5,2.5,true");
}
#[test]
fn format_named_repeated_placeholder() {
let html = safe_html_format!("{x} and {x}", x = "a<b");
assert_eq!(html.as_str(), "a<b and a<b");
}
#[test]
fn format_named_argument_shadowing_local() {
let name = "x&y";
let html = safe_html_format!("<i>{name}</i>", name = name);
assert_eq!(html.as_str(), "<i>x&y</i>");
}
#[test]
fn format_raw_identifier_argument() {
let html = safe_html_format!("<x kind=\"{type}\">{fn}</x>", r#type = "a&b", r#fn = 1);
assert_eq!(html.as_str(), "<x kind=\"a&b\">1</x>");
}
#[test]
fn format_literal_braces() {
let html = safe_html_format!("a {{b}} {v} {{{{", v = 1);
assert_eq!(html.as_str(), "a {b} 1 {{");
}
#[test]
fn format_no_arguments() {
let html = safe_html_format!("<hr> {{literal}}");
assert_eq!(html.as_str(), "<hr> {literal}");
}
#[test]
fn format_placeholder_at_boundaries() {
let html = safe_html_format!("{a}mid{b}", a = "<", b = ">");
assert_eq!(html.as_str(), "<mid>");
let adjacent = safe_html_format!("{a}{b}", a = "1<", b = "2>");
assert_eq!(adjacent.as_str(), "1<2>");
}
#[test]
fn format_unicode_literal_text() {
let html = safe_html_format!("héllo → {v} ✓", v = "å<b");
assert_eq!(html.as_str(), "héllo → å<b ✓");
}
#[test]
fn format_argument_evaluated_once() {
let mut calls = 0;
let mut value = || {
calls += 1;
"v"
};
let html = safe_html_format!("{x}/{x}", x = value());
assert_eq!(html.as_str(), "v/v");
assert_eq!(calls, 1);
}
#[test]
fn format_positional() {
let html = safe_html_format!("<b>{}</b><i>{}</i>", "a<b", 7);
assert_eq!(html.as_str(), "<b>a<b</b><i>7</i>");
}
#[test]
fn format_to_slice_writer() {
let mut buf = [0u8; 64];
let mut w = SliceWriter::new(&mut buf);
safe_html_format_to!(w, "<b>{msg}</b>", msg = "5 < 6").unwrap();
assert_eq!(w.as_str(), "<b>5 < 6</b>");
}
#[test]
fn format_to_positional_and_safe_types() {
let mut out = String::new();
safe_html_format_to!(
out,
"{}: {}",
SafeHtmlStr::from_constant("<b>ok</b>"),
"x&y"
)
.unwrap();
assert_eq!(out, "<b>ok</b>: x&y");
}
#[test]
fn format_to_capacity_error() {
let mut buf = [0u8; 4];
let mut w = SliceWriter::new(&mut buf);
assert!(safe_html_format_to!(w, "{v} is too long", v = "value").is_err());
}
#[test]
fn builder_push_chain_and_finish() {
let mut b = SafeHtmlBuilder::new();
b.push(SafeHtml::from_constant("<p>"))
.push("a & b")
.push(42)
.push(SafeHtml::from_constant("</p>"));
assert_eq!(b.as_str(), "<p>a & b42</p>");
assert_eq!(b.len(), "<p>a & b42</p>".len());
assert!(!b.is_empty());
assert_eq!(b.finish().as_str(), "<p>a & b42</p>");
}
#[test]
fn builder_with_capacity_does_not_reallocate() {
let mut b = SafeHtmlBuilder::with_capacity(1024);
for i in 0..10 {
safe_html_format!(b, "<li>{i}</li>", i = i);
}
let html = b.finish();
assert!(html.as_str().starts_with("<li>0</li>"));
assert!(html.as_str().ends_with("<li>9</li>"));
}
#[test]
fn builder_format_named_and_positional() {
let mut b = SafeHtmlBuilder::new();
safe_html_format!(b, "<b>{v}</b>", v = "a<b");
safe_html_format!(b, "<i>{}</i>", "c&d");
safe_html_format!(b, "<hr>");
assert_eq!(b.finish().as_str(), "<b>a<b</b><i>c&d</i><hr>");
}
#[test]
fn builder_from_safe_html_and_back() {
let start = safe_html_cat!(SafeHtml::from_constant("<ul>"));
let mut b = SafeHtmlBuilder::from(start);
b.push(SafeHtml::from_constant("</ul>"));
let html: SafeHtml = b.into();
assert_eq!(html.as_str(), "<ul></ul>");
}
#[test]
fn builder_extend() {
let mut b = SafeHtmlBuilder::new();
b.extend(["a<b", "c&d"]);
assert_eq!(b.as_str(), "a<bc&d");
b.extend([safe_html_cat!("<i>"), SafeHtml::from_constant("<i>")]);
assert_eq!(b.as_str(), "a<bc&d<i><i>");
}
#[test]
fn builder_default_is_empty() {
let b = SafeHtmlBuilder::default();
assert!(b.is_empty());
assert_eq!(b.finish().as_str(), "");
}
#[test]
fn reference_parts_interpolate_like_values() {
let owned = String::from("a&b");
let safe = safe_html_cat!("c<d");
let html = safe_html_cat!(&owned, &&owned, &safe, &&safe);
assert_eq!(html.as_str(), "a&ba&bc<dc<d");
let mut b = SafeHtmlBuilder::new();
for (i, name) in ["x<y"].iter().enumerate() {
safe_html_format!(b, "{i}:{name}", i = i, name = name);
}
assert_eq!(b.finish().as_str(), "0:x<y");
}
#[test]
fn option_part_some_and_none() {
let flash: Option<SafeHtml> = Some(safe_html_cat!("hi & bye"));
let html = safe_html_cat!(flash, Option::<SafeHtml>::None, Some("x<y"), 1);
assert_eq!(html.as_str(), "hi & byex<y1");
}
#[test]
fn option_part_in_format_and_write() {
let none: Option<&str> = None;
let html = safe_html_format!("[{a}][{b}]", a = Some("v&w"), b = none);
assert_eq!(html.as_str(), "[v&w][]");
let mut buf = [0u8; 32];
let mut w = SliceWriter::new(&mut buf);
safe_html_write!(w, Some("a<b"), Option::<&str>::None).unwrap();
assert_eq!(w.as_str(), "a<b");
}
struct Money(i64);
impl core::fmt::Display for Money {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "<{}", self.0 / 100)?;
write!(f, ".{:02}>", self.0 % 100)
}
}
#[test]
fn disp_escapes_display_output() {
let html = safe_html_cat!("cost: ", disp(&Money(1234)));
assert_eq!(html.as_str(), "cost: <12.34>");
}
#[test]
fn disp_in_format_macro() {
let html = safe_html_format!("<td>{m}</td>", m = disp(Money(99)));
assert_eq!(html.as_str(), "<td><0.99></td>");
}
#[test]
fn disp_zero_alloc_streaming() {
let mut buf = [0u8; 32];
let mut w = SliceWriter::new(&mut buf);
safe_html_write!(w, disp(&Money(5))).unwrap();
assert_eq!(w.as_str(), "<0.05>");
}
#[test]
fn pre_escaped_string_double_escapes() {
let pre_escaped = String::from("a & b");
let html = safe_html_cat!(pre_escaped);
assert_eq!(html.as_str(), "a &amp; b");
}
#[test]
#[should_panic(expected = "no matching")]
fn checker_rejects_unknown_placeholder() {
safehtml::__private::check_named_format("{missing}", &["present"]);
}
#[test]
#[should_panic(expected = "never used")]
fn checker_rejects_unused_argument() {
safehtml::__private::check_named_format("no placeholders", &["extra"]);
}
#[test]
#[should_panic(expected = "unclosed placeholder")]
fn checker_rejects_unclosed_brace() {
safehtml::__private::check_named_format("a {name", &["name"]);
}
#[test]
#[should_panic(expected = "unclosed placeholder")]
fn checker_rejects_nested_open_brace() {
safehtml::__private::check_named_format("a {na{me}", &["name"]);
}
#[test]
#[should_panic(expected = "unmatched closing brace")]
fn checker_rejects_lone_closing_brace() {
safehtml::__private::check_named_format("a } b", &[]);
}
#[test]
#[should_panic(expected = "format specs")]
fn checker_rejects_format_specs() {
safehtml::__private::check_named_format("{name:>8}", &["name"]);
}
#[test]
#[should_panic(expected = "empty placeholder is not allowed")]
fn checker_rejects_empty_placeholder_in_named_form() {
safehtml::__private::check_named_format("{} and {name}", &["name"]);
}
#[test]
#[should_panic(expected = "duplicate named argument")]
fn checker_rejects_duplicate_names() {
safehtml::__private::check_named_format("{a}", &["a", "a"]);
}
#[test]
#[should_panic(expected = "must equal the number of arguments")]
fn checker_rejects_positional_count_mismatch() {
safehtml::__private::check_positional_format("{} {}", 3);
}
#[test]
#[should_panic(expected = "only empty placeholders")]
fn checker_rejects_named_placeholder_in_positional_form() {
safehtml::__private::check_positional_format("{name}", 1);
}
#[test]
fn checker_accepts_valid_forms() {
safehtml::__private::check_named_format("{{}} {a} {b} {a}", &["a", "b"]);
safehtml::__private::check_named_format("{long_name} {x}", &["x", "long_name"]);
safehtml::__private::check_positional_format("{} {{x}} {}", 2);
safehtml::__private::check_named_format("{type}", &["r#type"]);
safehtml::__private::unit("x");
assert!(safehtml::__private::has_brace("a{b"));
assert!(safehtml::__private::has_brace("a}b"));
assert!(!safehtml::__private::has_brace("plain"));
}
#[test]
fn builder_reserve() {
let mut b = SafeHtmlBuilder::new();
b.reserve(128);
b.push("a");
assert_eq!(b.as_str(), "a");
}
#[test]
fn scanner_named_defensive_paths() {
let mut out = String::new();
safehtml::__private::format_named_to("{missing}|}|{{|}}|{open", &[], &mut out).unwrap();
assert_eq!(out, "|}|{|}|");
}
#[test]
fn scanner_positional_defensive_paths() {
let mut out = String::new();
let extra: &dyn safehtml::__private::DynPart = &"X";
safehtml::__private::format_positional_to("{name}|{}|{}|{{|}}|}", &[extra], &mut out).unwrap();
assert_eq!(out, "|X||{|}|}");
}