use crate::scan::{
CLASS_STANDARD, ESCAPE_CLASS, JS_SEP_CONT, JS_SEP_LAST_2028, JS_SEP_LAST_2029, JS_SEP_LEAD,
MODE_ASCII_ONLY, MODE_HTML_ENTITIES, MODE_HTML_SAFE, MODE_JS_SEPARATORS, MODE_SCRIPT_SAFE,
MODE_STANDARD, class_bits,
};
const fn escapes_js_separators<const MODE: u8>() -> bool {
matches!(MODE, MODE_SCRIPT_SAFE | MODE_HTML_SAFE | MODE_JS_SEPARATORS)
}
const fn escapes_html_entities<const MODE: u8>() -> bool {
matches!(MODE, MODE_HTML_SAFE | MODE_HTML_ENTITIES)
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
pub enum EscapeMode {
#[default]
Standard,
ScriptSafe,
AsciiOnly,
HtmlSafe,
HtmlEntities,
JsSeparators,
}
#[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
mod fallback {
use super::{
ESCAPE_CLASS, EmitBuf, MAX_ESCAPE_EXPANSION, class_bits, push_short, write_escape_run_raw,
};
pub(super) fn escape<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8]) {
let mut i = 0;
while i < s.len() {
let next = find_escape::<MODE>(s, i);
if next - i <= 16 {
push_short(out, &s[i..next]);
} else {
out.extend_from_slice(&s[i..next]);
}
if next >= s.len() {
return;
}
i = write_escape_run::<MODE>(out, s, next);
}
}
#[inline(always)]
fn find_escape<const MODE: u8>(s: &[u8], mut from: usize) -> usize {
while from + 8 <= s.len() {
let w = u64::from_le_bytes(s[from..from + 8].try_into().unwrap());
let m = crate::scan::swar_escape_mask::<MODE>(w);
if m != 0 {
return from + (m.trailing_zeros() >> 3) as usize;
}
from += 8;
}
while from < s.len() {
if ESCAPE_CLASS[s[from] as usize] & class_bits::<MODE>() != 0 {
return from;
}
from += 1;
}
from
}
fn write_escape_run<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8], i: usize) -> usize {
out.reserve(MAX_ESCAPE_EXPANSION * (s.len() - i) + 8);
unsafe {
let len = out.len();
let dst = out.as_mut_ptr().add(len);
let (next_i, wrote) = write_escape_run_raw::<MODE>(s, i, dst);
out.set_len(len + wrote);
next_i
}
}
}
pub unsafe trait EmitBuf {
fn reserve(&mut self, additional: usize);
fn len(&self) -> usize;
fn is_empty(&self) -> bool {
self.len() == 0
}
fn as_mut_ptr(&mut self) -> *mut u8;
unsafe fn set_len(&mut self, new_len: usize);
#[inline(always)]
fn push(&mut self, b: u8) {
self.reserve(1);
unsafe {
let len = self.len();
self.as_mut_ptr().add(len).write(b);
self.set_len(len + 1);
}
}
#[inline(always)]
fn extend_from_slice(&mut self, s: &[u8]) {
self.reserve(s.len());
unsafe {
let len = self.len();
core::ptr::copy_nonoverlapping(s.as_ptr(), self.as_mut_ptr().add(len), s.len());
self.set_len(len + s.len());
}
}
}
unsafe impl EmitBuf for Vec<u8> {
#[inline(always)]
fn reserve(&mut self, additional: usize) {
Vec::reserve(self, additional);
}
#[inline(always)]
fn len(&self) -> usize {
Vec::len(self)
}
#[inline(always)]
fn as_mut_ptr(&mut self) -> *mut u8 {
Vec::as_mut_ptr(self)
}
#[inline(always)]
unsafe fn set_len(&mut self, new_len: usize) {
unsafe { Vec::set_len(self, new_len) };
}
#[inline(always)]
fn push(&mut self, b: u8) {
Vec::push(self, b);
}
#[inline(always)]
fn extend_from_slice(&mut self, s: &[u8]) {
Vec::extend_from_slice(self, s);
}
}
#[inline(always)]
pub fn push_short<B: EmitBuf>(out: &mut B, s: &[u8]) {
let n = s.len();
if n > 16 {
out.extend_from_slice(s);
return;
}
out.reserve(16);
unsafe {
let len = out.len();
crate::scan::copy_small(s.as_ptr(), out.as_mut_ptr().add(len), n);
out.set_len(len + n);
}
}
#[inline(always)]
pub unsafe fn copy_short_raw(src: *const u8, dst: *mut u8, n: usize) {
unsafe {
if n <= 32 {
crate::scan::copy_small(src, dst, n);
} else {
std::ptr::copy_nonoverlapping(src, dst, n);
}
}
}
macro_rules! fused_scan_store {
($out:ident, $s:ident, $width:expr, $bits_per_lane:expr, $step:expr) => {{
let mut i = 0usize;
$out.reserve($s.len() + $width);
let mut base = $out.as_mut_ptr();
let mut w = $out.len();
let mut worst_case_reserved = false;
macro_rules! handle_escape_run {
() => {{
let (next_i, next_w) = escape_run_slow_path::<MODE, B>(
$out,
$s,
i,
w,
$width,
&mut worst_case_reserved,
&mut base,
);
i = next_i;
w = next_w;
if i >= $s.len() {
$out.set_len(w);
return;
}
}};
}
loop {
while i + $width <= $s.len() {
let mask: u64 = $step($s.as_ptr().add(i), base.add(w));
if mask == 0 {
i += $width;
w += $width;
continue;
}
let k = mask.trailing_zeros() as usize / $bits_per_lane;
i += k;
w += k;
let b = *$s.get_unchecked(i);
if worst_case_reserved && ESCAPE_CLASS[b as usize] & CLASS_STANDARD != 0 {
if b == b'"' || b == b'\\' {
base.add(w).write(b'\\');
base.add(w + 1).write(b);
w += 2;
} else {
std::ptr::copy_nonoverlapping(ESC_SEQ[b as usize].as_ptr(), base.add(w), 8);
w += ESC_LEN[b as usize] as usize;
}
i += 1;
if i >= $s.len() {
$out.set_len(w);
return;
}
} else {
handle_escape_run!();
}
}
let rem = $s.len() - i;
if rem == 0 {
$out.set_len(w);
return;
}
let chunk = crate::scan::padded_tail::<{ $width }>(&$s[i..]);
let keep_low_rem_lanes: u64 = u64::MAX >> (64 - $bits_per_lane * rem);
let mask: u64 = $step(chunk.as_ptr(), base.add(w)) & keep_low_rem_lanes;
if mask == 0 {
$out.set_len(w + rem);
return;
}
let k = mask.trailing_zeros() as usize / $bits_per_lane;
i += k;
w += k;
handle_escape_run!();
}
}};
}
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "avx2")]
unsafe fn escape_fused_avx2<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8]) {
unsafe { fused_scan_store!(out, s, 32, 1, crate::scan::x86::avx2_copy_scan::<MODE>) }
}
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "avx512bw")]
#[allow(dead_code)]
unsafe fn escape_fused_avx512<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8]) {
unsafe { fused_scan_store!(out, s, 64, 1, crate::scan::x86::avx512_copy_scan::<MODE>) }
}
const HEX: &[u8; 16] = b"0123456789abcdef";
const MAX_ESCAPE_EXPANSION: usize = 6;
#[inline]
unsafe fn write_u16_escape_raw(dst: *mut u8, cp: u16) -> usize {
unsafe {
dst.write(b'\\');
dst.add(1).write(b'u');
dst.add(2).write(HEX[(cp >> 12) as usize & 0xF]);
dst.add(3).write(HEX[(cp >> 8) as usize & 0xF]);
dst.add(4).write(HEX[(cp >> 4) as usize & 0xF]);
dst.add(5).write(HEX[cp as usize & 0xF]);
}
6
}
#[inline]
fn decode_utf8(s: &[u8], i: usize) -> (u32, usize) {
let b0 = u32::from(s[i]);
if b0 < 0xE0 {
(((b0 & 0x1F) << 6) | (u32::from(s[i + 1]) & 0x3F), 2)
} else if b0 < 0xF0 {
(
((b0 & 0x0F) << 12)
| ((u32::from(s[i + 1]) & 0x3F) << 6)
| (u32::from(s[i + 2]) & 0x3F),
3,
)
} else {
(
((b0 & 0x07) << 18)
| ((u32::from(s[i + 1]) & 0x3F) << 12)
| ((u32::from(s[i + 2]) & 0x3F) << 6)
| (u32::from(s[i + 3]) & 0x3F),
4,
)
}
}
static ESC_LEN: [u8; 256] = {
let mut t = [0u8; 256];
let mut i = 0;
while i < 0x20 {
t[i] = match i as u8 {
0x08 | 0x0C | b'\n' | b'\r' | b'\t' => 2,
_ => 6,
};
i += 1;
}
t[b'"' as usize] = 2;
t[b'\\' as usize] = 2;
t
};
static ESC_SEQ: [[u8; 8]; 256] = {
const HEX: &[u8; 16] = b"0123456789abcdef";
let mut t = [[0u8; 8]; 256];
let mut i = 0;
while i < 0x20 {
let b = i as u8;
t[i] = match b {
0x08 => *b"\\b\0\0\0\0\0\0",
0x0C => *b"\\f\0\0\0\0\0\0",
b'\n' => *b"\\n\0\0\0\0\0\0",
b'\r' => *b"\\r\0\0\0\0\0\0",
b'\t' => *b"\\t\0\0\0\0\0\0",
_ => [
b'\\',
b'u',
b'0',
b'0',
HEX[(b >> 4) as usize],
HEX[(b & 0xF) as usize],
0,
0,
],
};
i += 1;
}
t[b'"' as usize] = *b"\\\"\0\0\0\0\0\0";
t[b'\\' as usize] = *b"\\\\\0\0\0\0\0\0";
t
};
unsafe fn write_escape_run_raw<const MODE: u8>(
s: &[u8],
mut i: usize,
dst: *mut u8,
) -> (usize, usize) {
let mode_bits: u8 = class_bits::<MODE>();
let mut w = 0usize;
unsafe {
loop {
let b = s[i];
if b == b'"' {
dst.add(w).write(b'\\');
dst.add(w + 1).write(b'"');
w += 2;
i += 1;
} else if b == b'\\' {
dst.add(w).write(b'\\');
dst.add(w + 1).write(b'\\');
w += 2;
i += 1;
} else if b < 0x20 {
std::ptr::copy_nonoverlapping(ESC_SEQ[b as usize].as_ptr(), dst.add(w), 8);
w += ESC_LEN[b as usize] as usize;
i += 1;
} else if MODE == MODE_SCRIPT_SAFE && b == b'/' {
dst.add(w).write(b'\\');
dst.add(w + 1).write(b'/');
w += 2;
i += 1;
} else if escapes_html_entities::<MODE>() && (b == b'<' || b == b'>' || b == b'&') {
w += write_u16_escape_raw(dst.add(w), u16::from(b));
i += 1;
} else if escapes_js_separators::<MODE>() && b == JS_SEP_LEAD {
if s.get(i + 1) == Some(&JS_SEP_CONT)
&& matches!(s.get(i + 2), Some(&(JS_SEP_LAST_2028 | JS_SEP_LAST_2029)))
{
w += write_u16_escape_raw(
dst.add(w),
0x2028 + u16::from(s[i + 2] - JS_SEP_LAST_2028),
);
i += 3;
} else {
dst.add(w).write(JS_SEP_LEAD);
w += 1;
i += 1;
}
} else if MODE == MODE_ASCII_ONLY && b >= 0x80 {
let (cp, len) = decode_utf8(s, i);
i += len;
if cp >= 0x10000 {
let v = cp - 0x10000;
w += write_u16_escape_raw(dst.add(w), 0xD800 + (v >> 10) as u16);
w += write_u16_escape_raw(dst.add(w), 0xDC00 + (v & 0x3FF) as u16);
} else {
w += write_u16_escape_raw(dst.add(w), cp as u16);
}
} else {
dst.add(w).write(b);
w += 1;
i += 1;
}
if MODE != MODE_ASCII_ONLY
|| i >= s.len()
|| ESCAPE_CLASS[s[i] as usize] & mode_bits == 0
{
return (i, w);
}
}
}
}
#[cold]
fn escape_run_slow_path<const MODE: u8, B: EmitBuf>(
out: &mut B,
s: &[u8],
i: usize,
w: usize,
width: usize,
worst_case_reserved: &mut bool,
base: &mut *mut u8,
) -> (usize, usize) {
if !*worst_case_reserved {
let needed = w + MAX_ESCAPE_EXPANSION * (s.len() - i) + width + 8;
unsafe { out.set_len(w) };
out.reserve(needed.saturating_sub(w));
*base = out.as_mut_ptr();
*worst_case_reserved = true;
}
let (next_i, wrote) = unsafe { write_escape_run_raw::<MODE>(s, i, base.add(w)) };
(next_i, w + wrote)
}
#[cfg(target_arch = "x86_64")]
const AVX2_MIN_LEN: usize = 16;
fn escape_impl<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8]) {
#[cfg(target_arch = "x86_64")]
if s.len() >= AVX2_MIN_LEN && std::arch::is_x86_feature_detected!("avx2") {
unsafe { escape_fused_avx2::<MODE, B>(out, s) }
} else {
escape_fused_16::<MODE, B>(out, s);
}
#[cfg(target_arch = "aarch64")]
escape_fused_16::<MODE, B>(out, s);
#[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
fallback::escape::<MODE, B>(out, s);
}
#[cfg(target_arch = "aarch64")]
#[inline(always)]
fn escape_fused_16<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8]) {
unsafe { fused_scan_store!(out, s, 16, 4, crate::scan::neon::copy_scan::<MODE>) }
}
#[cfg(target_arch = "x86_64")]
#[inline(always)]
fn escape_fused_16<const MODE: u8, B: EmitBuf>(out: &mut B, s: &[u8]) {
unsafe { fused_scan_store!(out, s, 16, 1, crate::scan::x86::sse2_copy_scan::<MODE>) }
}
pub fn escape_into<B: EmitBuf>(out: &mut B, s: &[u8], mode: EscapeMode) {
match mode {
EscapeMode::Standard => escape_impl::<MODE_STANDARD, B>(out, s),
EscapeMode::ScriptSafe => escape_impl::<MODE_SCRIPT_SAFE, B>(out, s),
EscapeMode::AsciiOnly => escape_impl::<MODE_ASCII_ONLY, B>(out, s),
EscapeMode::HtmlSafe => escape_impl::<MODE_HTML_SAFE, B>(out, s),
EscapeMode::HtmlEntities => escape_impl::<MODE_HTML_ENTITIES, B>(out, s),
EscapeMode::JsSeparators => escape_impl::<MODE_JS_SEPARATORS, B>(out, s),
}
}
static DIGIT_PAIRS: [u8; 200] = {
let mut t = [0u8; 200];
let mut i = 0;
while i < 100 {
t[i * 2] = b'0' + (i / 10) as u8;
t[i * 2 + 1] = b'0' + (i % 10) as u8;
i += 1;
}
t
};
#[inline(always)]
fn decimal_len_u64(u: u64) -> usize {
static POW10: [u64; 19] = [
10,
100,
1_000,
10_000,
100_000,
1_000_000,
10_000_000,
100_000_000,
1_000_000_000,
10_000_000_000,
100_000_000_000,
1_000_000_000_000,
10_000_000_000_000,
100_000_000_000_000,
1_000_000_000_000_000,
10_000_000_000_000_000,
100_000_000_000_000_000,
1_000_000_000_000_000_000,
10_000_000_000_000_000_000,
];
let bits = 63 ^ (u | 1).leading_zeros() as usize;
let approx = (bits * 1233) >> 12;
approx + 1 + usize::from(u >= POW10[approx])
}
#[inline]
pub fn write_i64<B: EmitBuf>(out: &mut B, v: i64) {
out.reserve(I64_MAX_LEN);
unsafe {
let len = out.len();
let n = write_i64_raw(out.as_mut_ptr().add(len), v);
out.set_len(len + n);
}
}
pub fn write_f64<B: EmitBuf>(out: &mut B, f: f64) {
debug_assert!(f.is_finite(), "write_f64 requires a finite value");
crate::grisu2::dtoa(f, out);
}
pub const F64_MAX_LEN: usize = crate::grisu2::DTOA_MAX;
pub unsafe fn write_f64_raw(dst: *mut u8, f: f64) -> usize {
unsafe { crate::grisu2::dtoa_raw(f, dst) }
}
pub const I64_MAX_LEN: usize = 20;
pub unsafe fn write_i64_raw(dst: *mut u8, v: i64) -> usize {
let neg = v < 0;
let mut u = v.unsigned_abs();
unsafe {
let mut w = 0usize;
if neg {
*dst = b'-';
w = 1;
}
let len = decimal_len_u64(u);
let digits_start = dst.add(w);
let mut p = digits_start.add(len);
while u >= 100 {
let pair = ((u % 100) as usize) * 2;
u /= 100;
p = p.sub(2);
p.copy_from_nonoverlapping(DIGIT_PAIRS.as_ptr().add(pair), 2);
}
if u >= 10 {
p = p.sub(2);
p.copy_from_nonoverlapping(DIGIT_PAIRS.as_ptr().add((u as usize) * 2), 2);
} else {
p = p.sub(1);
*p = b'0' + u as u8;
}
debug_assert!(p == digits_start);
w + len
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn write_i64_matches_display_across_digit_boundaries() {
let mut cases: Vec<i64> = vec![0, i64::MIN, i64::MAX];
let mut p: i64 = 1;
for _ in 0..18 {
p *= 10;
cases.extend([p - 1, p, p + 1, -(p - 1), -p, -(p + 1)]);
}
for v in cases {
let mut out = Vec::new();
write_i64(&mut out, v);
assert_eq!(out, v.to_string().into_bytes(), "value {v}");
}
}
fn esc(s: &str, mode: EscapeMode) -> String {
let exact: Box<[u8]> = s.as_bytes().to_vec().into_boxed_slice();
let mut out = Vec::new();
escape_into(&mut out, &exact, mode);
String::from_utf8(out).unwrap()
}
#[test]
fn standard_escapes() {
assert_eq!(esc("plain", EscapeMode::Standard), "plain");
assert_eq!(esc("a\"b\\c", EscapeMode::Standard), "a\\\"b\\\\c");
assert_eq!(
esc("\n\t\r\u{8}\u{c}", EscapeMode::Standard),
"\\n\\t\\r\\b\\f"
);
assert_eq!(esc("\u{1}", EscapeMode::Standard), "\\u0001");
assert_eq!(esc("héllo", EscapeMode::Standard), "héllo");
let long = "x".repeat(1000);
assert_eq!(esc(&long, EscapeMode::Standard), long);
let mixed = format!("{long}\"{long}");
assert_eq!(
esc(&mixed, EscapeMode::Standard),
format!("{long}\\\"{long}")
);
}
fn esc_reference(s: &str, mode: EscapeMode) -> String {
use std::fmt::Write;
let mut out = String::new();
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\u{8}' => out.push_str("\\b"),
'\u{c}' => out.push_str("\\f"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
c if (c as u32) < 0x20 => {
let _ = write!(out, "\\u{:04x}", c as u32);
}
'/' if mode == EscapeMode::ScriptSafe => out.push_str("\\/"),
'<' | '>' | '&'
if mode == EscapeMode::HtmlSafe || mode == EscapeMode::HtmlEntities =>
{
let _ = write!(out, "\\u{:04x}", c as u32);
}
'\u{2028}' | '\u{2029}'
if matches!(
mode,
EscapeMode::ScriptSafe | EscapeMode::HtmlSafe | EscapeMode::JsSeparators
) =>
{
let _ = write!(out, "\\u{:04x}", c as u32);
}
c if (c as u32) >= 0x80 && mode == EscapeMode::AsciiOnly => {
if (c as u32) >= 0x10000 {
let mut units = [0u16; 2];
c.encode_utf16(&mut units);
let _ = write!(out, "\\u{:04x}\\u{:04x}", units[0], units[1]);
} else {
let _ = write!(out, "\\u{:04x}", c as u32);
}
}
c => out.push(c),
}
}
out
}
#[test]
fn escape_boundary_sweep() {
for mode in [
EscapeMode::Standard,
EscapeMode::ScriptSafe,
EscapeMode::AsciiOnly,
EscapeMode::HtmlSafe,
EscapeMode::HtmlEntities,
EscapeMode::JsSeparators,
] {
for len in 0..=40 {
let clean: String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN"[..len].to_string();
assert_eq!(esc(&clean, mode), esc_reference(&clean, mode), "len {len}");
for plant in *b"\"\n&<>/" {
for pos in 0..len {
let mut bytes = clean.clone().into_bytes();
bytes[pos] = plant;
let s = String::from_utf8(bytes).unwrap();
assert_eq!(
esc(&s, mode),
esc_reference(&s, mode),
"len {len} {:?} at {pos}",
plant as char
);
}
}
}
for pad in 0..=35 {
let s = format!("{}é\u{2028}\u{1F600}", "y".repeat(pad));
assert_eq!(esc(&s, mode), esc_reference(&s, mode), "pad {pad}");
}
}
}
#[test]
fn push_short_any_length() {
for len in 0..=40 {
let src: Vec<u8> = (0..len as u8).collect();
let mut out = b"prefix".to_vec();
push_short(&mut out, &src);
assert_eq!(&out[..6], b"prefix");
assert_eq!(&out[6..], &src[..], "len {len}");
}
}
#[test]
fn script_safe_escapes() {
assert_eq!(esc("a/b", EscapeMode::ScriptSafe), "a\\/b");
assert_eq!(
esc("\u{2028}\u{2029}", EscapeMode::ScriptSafe),
"\\u2028\\u2029"
);
assert_eq!(esc("\u{20AC}", EscapeMode::ScriptSafe), "\u{20AC}");
}
#[test]
fn html_safe_escapes() {
assert_eq!(
esc("<script>a && b</script>", EscapeMode::HtmlSafe),
"\\u003cscript\\u003ea \\u0026\\u0026 b\\u003c/script\\u003e"
);
assert_eq!(
esc("\u{2028}\u{2029}", EscapeMode::HtmlSafe),
"\\u2028\\u2029"
);
assert_eq!(esc("a/b \u{20AC}", EscapeMode::HtmlSafe), "a/b \u{20AC}");
assert_eq!(esc("héllo", EscapeMode::HtmlSafe), "héllo");
}
#[test]
fn separator_lead_tails_pass_through() {
let em_dash = [0xE2, 0x80, 0x94];
for mode in [
EscapeMode::ScriptSafe,
EscapeMode::HtmlSafe,
EscapeMode::JsSeparators,
] {
for tail in [&[0xE2][..], &[0xE2, 0x80][..], &em_dash[..]] {
let mut input = vec![b'x'; 37];
input.extend_from_slice(tail);
let mut out = Vec::new();
escape_into(&mut out, &input, mode);
assert_eq!(out, input, "{mode:?} tail {tail:?}");
}
}
}
#[test]
fn copy_short_raw_any_length() {
for n in 0..=64 {
let src: Vec<u8> = (0..n as u8).collect();
let mut dst = vec![0xAA; n];
unsafe { copy_short_raw(src.as_ptr(), dst.as_mut_ptr(), n) };
assert_eq!(dst, src, "n {n}");
}
}
#[test]
fn partial_html_profiles_escape_only_their_set() {
assert_eq!(
esc("a<b \u{2028}", EscapeMode::HtmlEntities),
"a\\u003cb \u{2028}"
);
assert_eq!(esc("a<b \u{2028}", EscapeMode::JsSeparators), "a<b \\u2028");
}
#[test]
fn ascii_only_escapes() {
assert_eq!(esc("héllo", EscapeMode::AsciiOnly), "h\\u00e9llo");
assert_eq!(esc("\u{1F600}", EscapeMode::AsciiOnly), "\\ud83d\\ude00");
assert_eq!(
esc("κόσμε", EscapeMode::AsciiOnly),
"\\u03ba\\u03cc\\u03c3\\u03bc\\u03b5"
);
}
#[test]
fn float_fpconv_format() {
let cases: &[(f64, &str)] = &[
(0.0, "0.0"),
(-0.0, "-0.0"),
(5.0, "5.0"),
(1.5, "1.5"),
(0.0001, "0.0001"),
(1e-5, "0.00001"),
(1e14, "100000000000000.0"),
(1e15, "1e+15"),
(1e16, "1e+16"),
(1.23456789e13, "12345678900000.0"),
(1.5e-7, "0.00000015"),
(1e100, "1e+100"),
(-2.5, "-2.5"),
(1.0 / 3.0, "0.3333333333333333"),
(2.34387207031, "2.3438720703100002"),
(-61.14917000000003, "-61.149170000000026"),
(0.130293816489, "0.13029381648899999"),
(1.7976931348623157e308, "1.7976931348623157e+308"),
(5e-324, "5e-324"),
];
for &(f, want) in cases {
let mut out = Vec::new();
write_f64(&mut out, f);
assert_eq!(std::str::from_utf8(&out).unwrap(), want, "for {f:e}");
}
}
#[test]
fn integers() {
for v in [0i64, 1, -1, i64::MAX, i64::MIN, 42, -12345678901234] {
let mut out = Vec::new();
write_i64(&mut out, v);
assert_eq!(String::from_utf8(out).unwrap(), v.to_string());
}
}
}