scolapasta_string_escape/
literal.rs

1use core::fmt;
2use core::iter::FusedIterator;
3use core::slice;
4use core::str;
5
6/// Returns whether the given [`char`] has an ASCII literal escape code.
7///
8/// Control characters in the range `0x00..=0x1F`, `"`, `\` and `DEL` have
9/// non-trivial escapes.
10///
11/// # Examples
12///
13/// ```
14/// # use core::char::REPLACEMENT_CHARACTER;
15/// # use scolapasta_string_escape::ascii_char_with_escape;
16/// assert_eq!(ascii_char_with_escape('\0'), Some(r"\x00"));
17/// assert_eq!(ascii_char_with_escape('\n'), Some(r"\n"));
18/// assert_eq!(ascii_char_with_escape('"'), Some(r#"\""#));
19/// assert_eq!(ascii_char_with_escape('\\'), Some(r"\\"));
20///
21/// assert_eq!(ascii_char_with_escape('a'), None);
22/// assert_eq!(ascii_char_with_escape('Z'), None);
23/// assert_eq!(ascii_char_with_escape(';'), None);
24/// assert_eq!(ascii_char_with_escape('💎'), None);
25/// assert_eq!(ascii_char_with_escape(REPLACEMENT_CHARACTER), None);
26/// ```
27#[inline]
28#[must_use]
29pub const fn ascii_char_with_escape(ch: char) -> Option<&'static str> {
30    if !ch.is_ascii() {
31        return None;
32    }
33    let [ascii_byte, ..] = (ch as u32).to_le_bytes();
34    let escape = Literal::debug_escape(ascii_byte);
35    if escape.len() > 1 { Some(escape) } else { None }
36}
37
38/// Iterator of Ruby debug escape sequences for a byte.
39///
40/// This iterator's item type is [`char`].
41///
42/// Non-printable bytes like `0xFF` or `0x0C` are escaped to `\xFF` or `\f`.
43///
44/// ASCII printable characters are passed through as is unless they are `"` or
45/// `\` since these fields are used to delimit strings and escape sequences.
46///
47/// # Usage notes
48///
49/// This iterator operates on individual bytes, which makes it unsuitable for
50/// debug printing a conventionally UTF-8 byte string on its own. See
51/// [`format_debug_escape_into`] to debug format an entire byte string.
52///
53/// # Examples
54///
55/// Printable ASCII characters are passed through unescaped:
56///
57/// ```
58/// # use scolapasta_string_escape::Literal;
59/// let literal = Literal::from(b'a');
60/// assert_eq!(literal.collect::<String>(), "a");
61///
62/// let literal = Literal::from(b';');
63/// assert_eq!(literal.collect::<String>(), ";");
64/// ```
65///
66/// `"` and `\` are escaped:
67///
68/// ```
69/// # use scolapasta_string_escape::Literal;
70/// let literal = Literal::from(b'"');
71/// assert_eq!(literal.collect::<String>(), r#"\""#);
72///
73/// let literal = Literal::from(b'\\');
74/// assert_eq!(literal.collect::<String>(), r"\\");
75/// ```
76///
77/// ASCII control characters are escaped:
78///
79/// ```
80/// # use scolapasta_string_escape::Literal;
81/// let literal = Literal::from(b'\0');
82/// assert_eq!(literal.collect::<String>(), r"\x00");
83///
84/// let literal = Literal::from(b'\x0A');
85/// assert_eq!(literal.collect::<String>(), r"\n");
86///
87/// let literal = Literal::from(b'\x0C');
88/// assert_eq!(literal.collect::<String>(), r"\f");
89///
90/// let literal = Literal::from(b'\x7F');
91/// assert_eq!(literal.collect::<String>(), r"\x7F");
92/// ```
93///
94/// UTF-8 invalid bytes are escaped:
95///
96/// ```
97/// # use scolapasta_string_escape::Literal;
98/// let literal = Literal::from(b'\xFF');
99/// assert_eq!(literal.collect::<String>(), r"\xFF");
100/// ```
101///
102/// [`format_debug_escape_into`]: crate::format_debug_escape_into
103#[derive(Debug, Clone)]
104#[must_use = "this `Literal` is an `Iterator`, which should be consumed if constructed"]
105pub struct Literal(slice::Iter<'static, u8>);
106
107impl Default for Literal {
108    fn default() -> Self {
109        Self::empty()
110    }
111}
112
113impl Literal {
114    /// Create an empty literal iterator.
115    ///
116    /// The returned `Literal` always yields [`None`].
117    ///
118    /// # Examples
119    ///
120    /// ```
121    /// # use scolapasta_string_escape::Literal;
122    ///
123    /// let mut literal = Literal::empty();
124    /// assert_eq!(literal.as_str(), "");
125    /// assert_eq!(literal.next(), None);
126    /// ```
127    pub fn empty() -> Self {
128        Literal(b"".iter())
129    }
130
131    /// Views the underlying data as a subslice of the original data.
132    ///
133    /// This has `'static` lifetime, and so the iterator can continue to be used
134    /// while this exists.
135    ///
136    /// # Examples
137    ///
138    /// ```
139    /// # use scolapasta_string_escape::Literal;
140    /// let mut literal = Literal::from(b'\0');
141    ///
142    /// assert_eq!(literal.as_str(), r"\x00");
143    /// literal.next();
144    /// assert_eq!(literal.as_str(), "x00");
145    /// literal.next();
146    /// literal.next();
147    /// assert_eq!(literal.as_str(), "0");
148    /// literal.next();
149    /// assert_eq!(literal.as_str(), "");
150    /// ```
151    #[inline]
152    #[must_use]
153    pub fn as_str(&self) -> &'static str {
154        str::from_utf8(self.0.as_slice()).unwrap_or_default()
155    }
156
157    /// Return the debug escape code for the given byte.
158    ///
159    /// Debug escapes can be hex escapes (`\xFF`), control character escapes
160    /// (`\e`), or escape sequences for debug printing (`\"` or `\\`).
161    ///
162    /// Printable ASCII characters that do not have escape sequences are passed
163    /// through untouched.
164    ///
165    /// # Examples
166    ///
167    /// ```
168    /// # use scolapasta_string_escape::Literal;
169    /// assert_eq!(Literal::debug_escape(255), r"\xFF");
170    /// assert_eq!(Literal::debug_escape(0x1B), r"\e");
171    /// assert_eq!(Literal::debug_escape(b'"'), r#"\""#);
172    /// assert_eq!(Literal::debug_escape(b'\\'), r"\\");
173    /// assert_eq!(Literal::debug_escape(b'a'), "a");
174    /// ```
175    #[must_use]
176    pub const fn debug_escape(byte: u8) -> &'static str {
177        // Some control character bytes escape to non-hex literals:
178        //
179        // ```console
180        // [2.6.3] > :"\x00"
181        // => :"\x00"
182        // [2.6.3] > :"\x01"
183        // => :"\x01"
184        // [2.6.3] > :"\x02"
185        // => :"\x02"
186        // [2.6.3] > :"\x03"
187        // => :"\x03"
188        // [2.6.3] > :"\x04"
189        // => :"\x04"
190        // [2.6.3] > :"\x05"
191        // => :"\x05"
192        // [2.6.3] > :"\x06"
193        // => :"\x06"
194        // [2.6.3] > :"\x07"
195        // => :"\a"
196        // [2.6.3] > :"\x08"
197        // => :"\b"
198        // [2.6.3] > :"\x09"
199        // => :"\t"
200        // [2.6.3] > :"\x0A"
201        // => :"\n"
202        // [2.6.3] > :"\x0B"
203        // => :"\v"
204        // [2.6.3] > :"\x0C"
205        // => :"\f"
206        // [2.6.3] > :"\x0D"
207        // => :"\r"
208        // [2.6.3] > :"\x0E"
209        // => :"\x0E"
210        // [2.6.3] > :"\x0F"
211        // => :"\x0F"
212        // [2.6.3] > :"\x10"
213        // => :"\x10"
214        // [2.6.3] > :"\x11"
215        // => :"\x11"
216        // [2.6.3] > :"\x12"
217        // => :"\x12"
218        // [2.6.3] > :"\x13"
219        // => :"\x13"
220        // [2.6.3] > :"\x14"
221        // => :"\x14"
222        // [2.6.3] > :"\x15"
223        // => :"\x15"
224        // [2.6.3] > :"\x16"
225        // => :"\x16"
226        // [2.6.3] > :"\x17"
227        // => :"\x17"
228        // [2.6.3] > :"\x18"
229        // => :"\x18"
230        // [2.6.3] > :"\x19"
231        // => :"\x19"
232        // [2.6.3] > :"\x1A"
233        // => :"\x1A"
234        // [2.6.3] > :"\x1B"
235        // => :"\e"
236        // [2.6.3] > :"\x1C"
237        // => :"\x1C"
238        // [2.6.3] > :"\x1D"
239        // => :"\x1D"
240        // [2.6.3] > :"\x1E"
241        // => :"\x1E"
242        // [2.6.3] > :"\x1F"
243        // => :"\x1F"
244        // [2.6.3] > :"\x20"
245        // => :" "
246        // [2.6.3] > '"'.ord
247        // => 34
248        // [2.6.3] > '"'.ord.to_s(16)
249        // => "22"
250        // [2.6.3] > :"\x22"
251        // => :"\""
252        // [2.6.3] > '\\'.ord
253        // => 92
254        // [2.6.3] > '\\'.ord.to_s(16)
255        // => "5c"
256        // [2.6.3] > :"\x5C"
257        // => :"\\"
258        // ```
259        #[rustfmt::skip]
260        const TABLE: [&str; 256] = [
261            r"\x00", r"\x01", r"\x02", r"\x03", r"\x04", r"\x05", r"\x06",   r"\a",
262              r"\b",   r"\t",   r"\n",   r"\v",   r"\f",   r"\r", r"\x0E", r"\x0F",
263            r"\x10", r"\x11", r"\x12", r"\x13", r"\x14", r"\x15", r"\x16", r"\x17",
264            r"\x18", r"\x19", r"\x1A",   r"\e", r"\x1C", r"\x1D", r"\x1E", r"\x1F",
265                " ",     "!", r#"\""#,    "#",     "$",     "%",     "&",      "'",
266                "(",     ")",     "*",    "+",     ",",     "-",     ".",      "/",
267                "0",     "1",     "2",    "3",     "4",     "5",     "6",      "7",
268                "8",     "9",     ":",    ";",     "<",     "=",     ">",      "?",
269                "@",     "A",     "B",    "C",     "D",     "E",     "F",      "G",
270                "H",     "I",     "J",    "K",     "L",     "M",     "N",      "O",
271                "P",     "Q",     "R",    "S",     "T",     "U",     "V",      "W",
272                "X",     "Y",     "Z",    "[",   r"\\",     "]",     "^",      "_",
273                "`",     "a",     "b",    "c",     "d",     "e",     "f",      "g",
274                "h",     "i",     "j",    "k",     "l",     "m",     "n",      "o",
275                "p",     "q",     "r",    "s",     "t",     "u",     "v",      "w",
276                "x",     "y",     "z",    "{",     "|",     "}",     "~",  r"\x7F",
277            r"\x80", r"\x81", r"\x82", r"\x83", r"\x84", r"\x85", r"\x86", r"\x87",
278            r"\x88", r"\x89", r"\x8A", r"\x8B", r"\x8C", r"\x8D", r"\x8E", r"\x8F",
279            r"\x90", r"\x91", r"\x92", r"\x93", r"\x94", r"\x95", r"\x96", r"\x97",
280            r"\x98", r"\x99", r"\x9A", r"\x9B", r"\x9C", r"\x9D", r"\x9E", r"\x9F",
281            r"\xA0", r"\xA1", r"\xA2", r"\xA3", r"\xA4", r"\xA5", r"\xA6", r"\xA7",
282            r"\xA8", r"\xA9", r"\xAA", r"\xAB", r"\xAC", r"\xAD", r"\xAE", r"\xAF",
283            r"\xB0", r"\xB1", r"\xB2", r"\xB3", r"\xB4", r"\xB5", r"\xB6", r"\xB7",
284            r"\xB8", r"\xB9", r"\xBA", r"\xBB", r"\xBC", r"\xBD", r"\xBE", r"\xBF",
285            r"\xC0", r"\xC1", r"\xC2", r"\xC3", r"\xC4", r"\xC5", r"\xC6", r"\xC7",
286            r"\xC8", r"\xC9", r"\xCA", r"\xCB", r"\xCC", r"\xCD", r"\xCE", r"\xCF",
287            r"\xD0", r"\xD1", r"\xD2", r"\xD3", r"\xD4", r"\xD5", r"\xD6", r"\xD7",
288            r"\xD8", r"\xD9", r"\xDA", r"\xDB", r"\xDC", r"\xDD", r"\xDE", r"\xDF",
289            r"\xE0", r"\xE1", r"\xE2", r"\xE3", r"\xE4", r"\xE5", r"\xE6", r"\xE7",
290            r"\xE8", r"\xE9", r"\xEA", r"\xEB", r"\xEC", r"\xED", r"\xEE", r"\xEF",
291            r"\xF0", r"\xF1", r"\xF2", r"\xF3", r"\xF4", r"\xF5", r"\xF6", r"\xF7",
292            r"\xF8", r"\xF9", r"\xFA", r"\xFB", r"\xFC", r"\xFD", r"\xFE", r"\xFF",
293        ];
294
295        TABLE[byte as usize]
296    }
297}
298
299impl From<u8> for Literal {
300    /// Map from a `u8` to a String literal of debug escape code.
301    ///
302    /// Debug escapes can be hex escapes (`\xFF`), control character escapes
303    /// (`\e`), or escape sequences for debug printing (`\"` or `\\`).
304    ///
305    /// Printable ASCII characters that are not escape sequences are passed
306    /// through untouched.
307    #[inline]
308    fn from(byte: u8) -> Self {
309        let escape = Self::debug_escape(byte);
310        Self(escape.as_bytes().iter())
311    }
312}
313
314impl Iterator for Literal {
315    type Item = char;
316
317    #[inline]
318    fn next(&mut self) -> Option<Self::Item> {
319        self.0.next().map(|&byte| byte as char)
320    }
321
322    #[inline]
323    fn nth(&mut self, n: usize) -> Option<Self::Item> {
324        self.0.nth(n).map(|&byte| byte as char)
325    }
326
327    #[inline]
328    fn count(self) -> usize {
329        self.0.count()
330    }
331
332    #[inline]
333    fn size_hint(&self) -> (usize, Option<usize>) {
334        self.0.size_hint()
335    }
336
337    #[inline]
338    fn last(self) -> Option<Self::Item> {
339        self.0.last().map(|&byte| byte as char)
340    }
341}
342
343impl DoubleEndedIterator for Literal {
344    #[inline]
345    fn next_back(&mut self) -> Option<Self::Item> {
346        self.0.next_back().map(|&byte| byte as char)
347    }
348
349    #[inline]
350    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
351        self.0.nth_back(n).map(|&byte| byte as char)
352    }
353}
354
355impl FusedIterator for Literal {}
356
357/// Error that indicates a [`InvalidUtf8ByteSequence`] could not be constructed
358/// because the byte sequence contained more than three bytes.
359///
360/// This crate decodes conventionally UTF-8 binary strings with the
361/// "substitution of maximal subparts" strategy, which at most will return
362/// invalid byte sequences with length 3.
363///
364/// This error is fatal and indicates a bug in a library this crate depends on.
365#[derive(Default, Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
366pub struct ByteSequenceTooLongError {
367    _private: (),
368}
369
370impl ByteSequenceTooLongError {
371    /// Construct a new `ByteSequenceTooLongError`.
372    ///
373    /// # Examples
374    ///
375    /// ```
376    /// # use scolapasta_string_escape::ByteSequenceTooLongError;
377    /// const ERR: ByteSequenceTooLongError = ByteSequenceTooLongError::new();
378    /// ```
379    #[inline]
380    #[must_use]
381    pub const fn new() -> Self {
382        Self { _private: () }
383    }
384
385    /// Retrieve the error message associated with this byte sequence too long
386    /// error.
387    ///
388    /// # Examples
389    ///
390    /// ```
391    /// # use scolapasta_string_escape::ByteSequenceTooLongError;
392    /// let err = ByteSequenceTooLongError::new();
393    /// assert_eq!(
394    ///     err.message(),
395    ///     "Invalid UTF-8 byte literal sequences can be at most three bytes long"
396    /// );
397    /// ```
398    #[inline]
399    #[must_use]
400    pub const fn message(self) -> &'static str {
401        "Invalid UTF-8 byte literal sequences can be at most three bytes long"
402    }
403}
404
405impl fmt::Display for ByteSequenceTooLongError {
406    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
407        f.write_str(const { ByteSequenceTooLongError::new().message() })
408    }
409}
410
411#[cfg(feature = "std")]
412impl std::error::Error for ByteSequenceTooLongError {}
413
414/// Iterator of Ruby debug escape sequences for a contiguous invalid UTF-8 byte
415/// sequence.
416///
417/// This iterator's item type is [`char`].
418///
419/// Non-printable bytes like `0xFF` or `0x0C` are escaped to `\xFF` or `\f`.
420///
421/// # Usage notes
422///
423/// This iterator assumes it is constructed with invalid UTF-8 bytes and will
424/// always escape all bytes given to it.
425///
426/// # Examples
427///
428/// The bytes `\xF0\x9D\x9C` could lead to a valid UTF-8 sequence, but 3 of them
429/// on their own are invalid. All of these bytes should be hex escaped.
430///
431/// ```
432/// # use scolapasta_string_escape::InvalidUtf8ByteSequence;
433/// let invalid_byte_sequence = &b"\xF0\x9D\x9C"[..];
434/// let iter = InvalidUtf8ByteSequence::try_from(invalid_byte_sequence).unwrap();
435/// assert_eq!(iter.collect::<String>(), r"\xF0\x9D\x9C");
436/// ```
437#[derive(Default, Debug, Clone)]
438#[must_use = "this `InvalidUtf8ByteSequence` is an `Iterator`, which should be consumed if constructed"]
439pub struct InvalidUtf8ByteSequence {
440    one: Option<Literal>,
441    two: Option<Literal>,
442    three: Option<Literal>,
443}
444
445impl InvalidUtf8ByteSequence {
446    /// Construct a new, empty invalid UTF-8 byte sequence iterator.
447    ///
448    /// # Examples
449    ///
450    /// ```
451    /// # use scolapasta_string_escape::InvalidUtf8ByteSequence;
452    /// let iter = InvalidUtf8ByteSequence::new();
453    /// assert_eq!(iter.count(), 0);
454    /// ```
455    #[inline]
456    pub const fn new() -> Self {
457        Self {
458            one: None,
459            two: None,
460            three: None,
461        }
462    }
463
464    /// Construct a new, invalid UTF-8 byte sequence iterator with a single
465    /// invalid byte.
466    ///
467    /// # Examples
468    ///
469    /// ```
470    /// # use scolapasta_string_escape::InvalidUtf8ByteSequence;
471    /// let iter = InvalidUtf8ByteSequence::with_byte(0xFF);
472    /// assert_eq!(iter.collect::<String>(), r"\xFF");
473    /// ```
474    #[inline]
475    pub fn with_byte(byte: u8) -> Self {
476        Self {
477            one: Some(Literal::from(byte)),
478            two: None,
479            three: None,
480        }
481    }
482
483    /// Construct a new, invalid UTF-8 byte sequence iterator with two
484    /// consecutive invalid bytes.
485    ///
486    /// # Examples
487    ///
488    /// ```
489    /// # use scolapasta_string_escape::InvalidUtf8ByteSequence;
490    /// let iter = InvalidUtf8ByteSequence::with_two_bytes(0xE2, 0x98);
491    /// assert_eq!(iter.collect::<String>(), r"\xE2\x98");
492    /// ```
493    #[inline]
494    pub fn with_two_bytes(left: u8, right: u8) -> Self {
495        Self {
496            one: Some(Literal::from(left)),
497            two: Some(Literal::from(right)),
498            three: None,
499        }
500    }
501
502    /// Construct a new, invalid UTF-8 byte sequence iterator with three
503    /// consecutive invalid bytes.
504    ///
505    /// # Examples
506    ///
507    /// ```
508    /// # use scolapasta_string_escape::InvalidUtf8ByteSequence;
509    /// let iter = InvalidUtf8ByteSequence::with_three_bytes(0xF0, 0x9D, 0x9C);
510    /// assert_eq!(iter.collect::<String>(), r"\xF0\x9D\x9C");
511    /// ```
512    #[inline]
513    pub fn with_three_bytes(left: u8, mid: u8, right: u8) -> Self {
514        Self {
515            one: Some(Literal::from(left)),
516            two: Some(Literal::from(mid)),
517            three: Some(Literal::from(right)),
518        }
519    }
520}
521
522impl<'a> TryFrom<&'a [u8]> for InvalidUtf8ByteSequence {
523    type Error = ByteSequenceTooLongError;
524
525    #[inline]
526    fn try_from(bytes: &'a [u8]) -> Result<Self, Self::Error> {
527        match *bytes {
528            [] => Ok(Self::new()),
529            [byte] => Ok(Self::with_byte(byte)),
530            [left, right] => Ok(Self::with_two_bytes(left, right)),
531            [left, mid, right] => Ok(Self::with_three_bytes(left, mid, right)),
532            _ => Err(ByteSequenceTooLongError::new()),
533        }
534    }
535}
536
537impl Iterator for InvalidUtf8ByteSequence {
538    type Item = char;
539
540    #[inline]
541    fn next(&mut self) -> Option<Self::Item> {
542        self.one
543            .as_mut()
544            .and_then(Iterator::next)
545            .or_else(|| self.two.as_mut().and_then(Iterator::next))
546            .or_else(|| self.three.as_mut().and_then(Iterator::next))
547    }
548}
549
550impl DoubleEndedIterator for InvalidUtf8ByteSequence {
551    fn next_back(&mut self) -> Option<Self::Item> {
552        self.three
553            .as_mut()
554            .and_then(DoubleEndedIterator::next_back)
555            .or_else(|| self.two.as_mut().and_then(DoubleEndedIterator::next_back))
556            .or_else(|| self.one.as_mut().and_then(DoubleEndedIterator::next_back))
557    }
558}
559
560impl FusedIterator for InvalidUtf8ByteSequence {}
561
562/// Generation:
563///
564/// ```ruby
565/// pairs = (0x00..0xFF).to_a.map {|ch| ["0x#{ch.to_s(16).upcase}_u8", "r#{[ch].pack('c*').inspect}"]}
566/// puts "let test_cases = [#{pairs.map {|a, b| "#{b}"}.join ", "}];"
567/// ```
568#[cfg(test)]
569mod tests {
570    use alloc::string::String;
571
572    use super::Literal;
573
574    #[test]
575    fn exhaustive() {
576        #[rustfmt::skip]
577        let test_cases = (u8::MIN..=u8::MAX).zip(
578            [
579                r"\x00", r"\x01", r"\x02", r"\x03", r"\x04", r"\x05", r"\x06",   r"\a",
580                  r"\b",   r"\t",   r"\n",   r"\v",   r"\f",   r"\r", r"\x0E", r"\x0F",
581                r"\x10", r"\x11", r"\x12", r"\x13", r"\x14", r"\x15", r"\x16", r"\x17",
582                r"\x18", r"\x19", r"\x1A",   r"\e", r"\x1C", r"\x1D", r"\x1E", r"\x1F",
583                    " ",     "!", r#"\""#,    "#",     "$",     "%",     "&",      "'",
584                    "(",     ")",     "*",    "+",     ",",     "-",     ".",      "/",
585                    "0",     "1",     "2",    "3",     "4",     "5",     "6",      "7",
586                    "8",     "9",     ":",    ";",     "<",     "=",     ">",      "?",
587                    "@",     "A",     "B",    "C",     "D",     "E",     "F",      "G",
588                    "H",     "I",     "J",    "K",     "L",     "M",     "N",      "O",
589                    "P",     "Q",     "R",    "S",     "T",     "U",     "V",      "W",
590                    "X",     "Y",     "Z",    "[",   r"\\",     "]",     "^",      "_",
591                    "`",     "a",     "b",    "c",     "d",     "e",     "f",      "g",
592                    "h",     "i",     "j",    "k",     "l",     "m",     "n",      "o",
593                    "p",     "q",     "r",    "s",     "t",     "u",     "v",      "w",
594                    "x",     "y",     "z",    "{",     "|",     "}",     "~",  r"\x7F",
595                r"\x80", r"\x81", r"\x82", r"\x83", r"\x84", r"\x85", r"\x86", r"\x87",
596                r"\x88", r"\x89", r"\x8A", r"\x8B", r"\x8C", r"\x8D", r"\x8E", r"\x8F",
597                r"\x90", r"\x91", r"\x92", r"\x93", r"\x94", r"\x95", r"\x96", r"\x97",
598                r"\x98", r"\x99", r"\x9A", r"\x9B", r"\x9C", r"\x9D", r"\x9E", r"\x9F",
599                r"\xA0", r"\xA1", r"\xA2", r"\xA3", r"\xA4", r"\xA5", r"\xA6", r"\xA7",
600                r"\xA8", r"\xA9", r"\xAA", r"\xAB", r"\xAC", r"\xAD", r"\xAE", r"\xAF",
601                r"\xB0", r"\xB1", r"\xB2", r"\xB3", r"\xB4", r"\xB5", r"\xB6", r"\xB7",
602                r"\xB8", r"\xB9", r"\xBA", r"\xBB", r"\xBC", r"\xBD", r"\xBE", r"\xBF",
603                r"\xC0", r"\xC1", r"\xC2", r"\xC3", r"\xC4", r"\xC5", r"\xC6", r"\xC7",
604                r"\xC8", r"\xC9", r"\xCA", r"\xCB", r"\xCC", r"\xCD", r"\xCE", r"\xCF",
605                r"\xD0", r"\xD1", r"\xD2", r"\xD3", r"\xD4", r"\xD5", r"\xD6", r"\xD7",
606                r"\xD8", r"\xD9", r"\xDA", r"\xDB", r"\xDC", r"\xDD", r"\xDE", r"\xDF",
607                r"\xE0", r"\xE1", r"\xE2", r"\xE3", r"\xE4", r"\xE5", r"\xE6", r"\xE7",
608                r"\xE8", r"\xE9", r"\xEA", r"\xEB", r"\xEC", r"\xED", r"\xEE", r"\xEF",
609                r"\xF0", r"\xF1", r"\xF2", r"\xF3", r"\xF4", r"\xF5", r"\xF6", r"\xF7",
610                r"\xF8", r"\xF9", r"\xFA", r"\xFB", r"\xFC", r"\xFD", r"\xFE", r"\xFF",
611            ]
612        );
613        for (byte, literal) in test_cases {
614            let iter = Literal::from(byte);
615            assert_eq!(
616                iter.collect::<String>(),
617                literal,
618                "tested byte {byte}, expected {literal}"
619            );
620        }
621    }
622}
scolapasta_string_escape/literal.rs

scolapasta_string_escape/
literal.rs
