Add exhaustive escape_debug parity tests against Rust 1.93 reference

Validate escapeRune, EscapeString, EscapeCharAll, isPrintable, and
isGraphemeExtended against exact Rust 1.93 char::escape_debug() and
str::escape_debug() output for 160+ codepoints covering:

- All C0/C1 controls, full Latin-1 supplement boundary (0xA0-0xBF)
- Combining marks (Mn, Me, Mc), format chars, separators, BOM
- Halfwidth katakana, hangul jungseong, tag chars, variation selectors
- SMP and supplementary plane boundaries
- str first-vs-continuation grapheme extend distinction
- Round-trip correctness through Unquote for both escape modes

Signed-off-by: Phil Hassey <phil@strongdm.com>

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: philhassey

internal/rust/exhaustive_test.go

@@ -0,0 +1,315 @@
+package rust
+
+import (
+	"fmt"
+	"testing"
+)
+
+// TestEscapeRustParity validates escapeRune, EscapeString, EscapeCharAll,
+// isPrintable, and isGraphemeExtended against exact Rust 1.93
+// char::escape_debug / str::escape_debug reference output.
+func TestEscapeRustParity(t *testing.T) {
+	t.Parallel()
+
+	// escapeRune with ESCAPE_ALL must match Rust char::escape_debug().
+	// Reference data generated by running Rust 1.93 char::escape_debug()
+	// on each codepoint.
+	t.Run("char_escape_debug", func(t *testing.T) {
+		t.Parallel()
+		ref := map[rune]string{
+			// C0 controls 0x00-0x1F
+			0x0000: `\0`, 0x0001: `\u{1}`, 0x0002: `\u{2}`, 0x0003: `\u{3}`,
+			0x0004: `\u{4}`, 0x0005: `\u{5}`, 0x0006: `\u{6}`, 0x0007: `\u{7}`,
+			0x0008: `\u{8}`, 0x0009: `\t`, 0x000A: `\n`, 0x000B: `\u{b}`,
+			0x000C: `\u{c}`, 0x000D: `\r`, 0x000E: `\u{e}`, 0x000F: `\u{f}`,
+			0x0010: `\u{10}`, 0x0011: `\u{11}`, 0x0012: `\u{12}`, 0x0013: `\u{13}`,
+			0x0014: `\u{14}`, 0x0015: `\u{15}`, 0x0016: `\u{16}`, 0x0017: `\u{17}`,
+			0x0018: `\u{18}`, 0x0019: `\u{19}`, 0x001A: `\u{1a}`, 0x001B: `\u{1b}`,
+			0x001C: `\u{1c}`, 0x001D: `\u{1d}`, 0x001E: `\u{1e}`, 0x001F: `\u{1f}`,
+			// Special printable ASCII
+			0x0022: `\"`, 0x0027: `\'`, 0x005C: `\\`,
+			// DEL
+			0x007F: `\u{7f}`,
+			// C1 controls 0x80-0x9F
+			0x0080: `\u{80}`, 0x0081: `\u{81}`, 0x0082: `\u{82}`, 0x0083: `\u{83}`,
+			0x0084: `\u{84}`, 0x0085: `\u{85}`, 0x0086: `\u{86}`, 0x0087: `\u{87}`,
+			0x0088: `\u{88}`, 0x0089: `\u{89}`, 0x008A: `\u{8a}`, 0x008B: `\u{8b}`,
+			0x008C: `\u{8c}`, 0x008D: `\u{8d}`, 0x008E: `\u{8e}`, 0x008F: `\u{8f}`,
+			0x0090: `\u{90}`, 0x0091: `\u{91}`, 0x0092: `\u{92}`, 0x0093: `\u{93}`,
+			0x0094: `\u{94}`, 0x0095: `\u{95}`, 0x0096: `\u{96}`, 0x0097: `\u{97}`,
+			0x0098: `\u{98}`, 0x0099: `\u{99}`, 0x009A: `\u{9a}`, 0x009B: `\u{9b}`,
+			0x009C: `\u{9c}`, 0x009D: `\u{9d}`, 0x009E: `\u{9e}`, 0x009F: `\u{9f}`,
+			// Latin-1 supplement 0xA0-0xBF
+			0x00A0: `\u{a0}`,
+			0x00A1: "\u00A1", 0x00A2: "\u00A2", 0x00A3: "\u00A3",
+			0x00A4: "\u00A4", 0x00A5: "\u00A5", 0x00A6: "\u00A6", 0x00A7: "\u00A7",
+			0x00A8: "\u00A8", 0x00A9: "\u00A9", 0x00AA: "\u00AA", 0x00AB: "\u00AB",
+			0x00AC: "\u00AC",
+			0x00AD: `\u{ad}`,
+			0x00AE: "\u00AE", 0x00AF: "\u00AF",
+			0x00B0: "\u00B0", 0x00B1: "\u00B1", 0x00B2: "\u00B2", 0x00B3: "\u00B3",
+			0x00B4: "\u00B4", 0x00B5: "\u00B5", 0x00B6: "\u00B6", 0x00B7: "\u00B7",
+			0x00B8: "\u00B8", 0x00B9: "\u00B9", 0x00BA: "\u00BA", 0x00BB: "\u00BB",
+			0x00BC: "\u00BC", 0x00BD: "\u00BD", 0x00BE: "\u00BE", 0x00BF: "\u00BF",
+			// Combining marks (Mn) — grapheme extend → escaped
+			0x0300: `\u{300}`, 0x0301: `\u{301}`, 0x0302: `\u{302}`,
+			// Combining marks (Me) — grapheme extend → escaped
+			0x0488: `\u{488}`, 0x0489: `\u{489}`,
+			0x1ABE: `\u{1abe}`,
+			0x20DD: `\u{20dd}`, 0x20DE: `\u{20de}`,
+			// Spacing marks (Mc) — NOT grapheme extend, printable → pass through
+			0x0903: "\u0903", 0x093E: "\u093E", 0x0940: "\u0940",
+			// Format characters (Cf) — not printable → escaped
+			0x200B: `\u{200b}`, 0x200C: `\u{200c}`, 0x200D: `\u{200d}`,
+			0x200E: `\u{200e}`, 0x200F: `\u{200f}`,
+			0x202A: `\u{202a}`, 0x202E: `\u{202e}`,
+			0x0600: `\u{600}`, 0x0601: `\u{601}`, 0x061C: `\u{61c}`,
+			// Separators — not printable
+			0x2028: `\u{2028}`, 0x2029: `\u{2029}`,
+			// Invisible operators
+			0x2060: `\u{2060}`, 0x2061: `\u{2061}`,
+			// BOM
+			0xFEFF: `\u{feff}`,
+			// Interlinear annotation
+			0xFFF9: `\u{fff9}`, 0xFFFA: `\u{fffa}`, 0xFFFB: `\u{fffb}`,
+			// Specials
+			0xFFFC: "\uFFFC", 0xFFFD: "\uFFFD",
+			0xFFFE: `\u{fffe}`, 0xFFFF: `\u{ffff}`,
+			// Halfwidth katakana (Lm, Other_Grapheme_Extend)
+			0xFF9E: `\u{ff9e}`, 0xFF9F: `\u{ff9f}`,
+			// Unassigned
+			0x0378: `\u{378}`, 0x0379: `\u{379}`,
+			// Hangul jungseong — printable, not grapheme extend
+			0x1160: "\u1160", 0x1161: "\u1161",
+			// Tag characters — not printable
+			0xE0001: `\u{e0001}`, 0xE0020: `\u{e0020}`, 0xE007F: `\u{e007f}`,
+			// Variation selectors supplement — grapheme extend → escaped
+			0xE0100: `\u{e0100}`, 0xE01EF: `\u{e01ef}`,
+			// Past variation selectors — not printable
+			0xE01F0: `\u{e01f0}`,
+			// SMP
+			0x10000: "\U00010000", 0x1000C: `\u{1000c}`, 0x1F600: "\U0001F600",
+			// CJK extension B boundary
+			0x20000: "\U00020000", 0x2A6E0: `\u{2a6e0}`,
+		}
+		// Fill in all printable ASCII 0x20-0x7E
+		for r := rune(0x20); r <= 0x7E; r++ {
+			if _, ok := ref[r]; !ok {
+				ref[r] = string(r)
+			}
+		}
+		for r, want := range ref {
+			got := escapeRune(r, true)
+			if got != want {
+				t.Errorf("U+%04X: got %q, want %q", r, got, want)
+			}
+		}
+	})
+
+	// EscapeString must match Rust str::escape_debug():
+	// first char uses ESCAPE_ALL, continuation uses escape_grapheme_extended=false.
+	t.Run("str_escape_debug", func(t *testing.T) {
+		t.Parallel()
+		tests := []struct {
+			name string
+			in   string
+			want string
+		}{
+			{"hello", "hello", "hello"},
+			{"empty", "", ""},
+			{"null", "\x00", `\0`},
+			{"whitespace_controls", "\t\n\r", `\t\n\r`},
+			{"single_quote_mid", "a'b", `a\'b`},
+			{"single_quote_first", "'a", `\'a`},
+			{"double_quote_mid", "a\"b", `a\"b`},
+			{"backslash_mid", "a\\b", `a\\b`},
+			// Grapheme extend: first escaped, continuation raw
+			{"combining_cont", "a\u0300", "a\u0300"},
+			{"combining_first", "\u0300a", `\u{300}` + "a"},
+			{"two_combiners_after_base", "a\u0300\u0301", "a\u0300\u0301"},
+			{"two_combiners_no_base", "\u0300\u0301", `\u{300}` + "\u0301"},
+			{"katakana_cont", "a\uFF9E", "a\uFF9E"},
+			{"katakana_first", "\uFF9Ea", `\u{ff9e}` + "a"},
+			{"enclosing_cont", "a\u20DD", "a\u20DD"},
+			{"enclosing_first", "\u20DDa", `\u{20dd}` + "a"},
+			// Mc (NOT grapheme extend) — always raw
+			{"visarga_only", "\u0903", "\u0903"},
+			{"visarga_cont", "a\u0903", "a\u0903"},
+			// Non-printable — always escaped
+			{"zwj_only", "\u200D", `\u{200d}`},
+			{"zwj_cont", "a\u200D", `a\u{200d}`},
+			{"zwnj_only", "\u200C", `\u{200c}`},
+			{"zwnj_cont", "a\u200C", `a\u{200c}`},
+			{"bom", "\uFEFF", `\u{feff}`},
+			{"bom_cont", "a\uFEFF", `a\u{feff}`},
+			{"e_acute", "\u00E9", "\u00E9"},
+			{"soft_hyphen", string(rune(0xAD)), `\u{ad}`},
+			{"soft_hyphen_cont", "a" + string(rune(0xAD)), `a\u{ad}`},
+			{"nbsp", string(rune(0xA0)), `\u{a0}`},
+			{"nbsp_cont", "a" + string(rune(0xA0)), `a\u{a0}`},
+		}
+		for _, tc := range tests {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Parallel()
+				if got := EscapeString(tc.in); got != tc.want {
+					t.Errorf("got %q, want %q", got, tc.want)
+				}
+			})
+		}
+	})
+
+	// EscapeCharAll must escape grapheme extend in ALL positions
+	// (matches per-char char::escape_debug used by Rust Cedar patterns).
+	t.Run("char_all", func(t *testing.T) {
+		t.Parallel()
+		tests := []struct {
+			name string
+			in   string
+			want string
+		}{
+			{"plain", "hello", "hello"},
+			{"combining_cont", "a\u0300", `a\u{300}`},
+			{"combining_first", "\u0300a", `\u{300}` + "a"},
+			{"katakana_cont", "a\uFF9E", `a\u{ff9e}`},
+			{"visarga", "a\u0903", "a\u0903"}, // Mc only → raw
+		}
+		for _, tc := range tests {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Parallel()
+				if got := EscapeCharAll(tc.in); got != tc.want {
+					t.Errorf("got %q, want %q", got, tc.want)
+				}
+			})
+		}
+	})
+
+	// Grapheme extend chars must be escaped as first char, raw in continuation.
+	// Non-printable non-grapheme-extend chars must always be escaped.
+	t.Run("first_vs_continuation", func(t *testing.T) {
+		t.Parallel()
+		for _, r := range []rune{0x0300, 0x0301, 0x20DD, 0xFF9E, 0xFF9F, 0x0488} {
+			t.Run(fmt.Sprintf("grapheme_extend_U+%04X", r), func(t *testing.T) {
+				t.Parallel()
+				wantFirst := fmt.Sprintf(`\u{%x}`, r)
+				if got := EscapeString(string(r)); got != wantFirst {
+					t.Errorf("as first: got %q, want %q", got, wantFirst)
+				}
+				wantCont := "a" + string(r)
+				if got := EscapeString("a" + string(r)); got != wantCont {
+					t.Errorf("in continuation: got %q, want %q", got, wantCont)
+				}
+			})
+		}
+		for _, r := range []rune{0x200D, 0x00AD, 0x0080, 0xFFFE} {
+			t.Run(fmt.Sprintf("always_escaped_U+%04X", r), func(t *testing.T) {
+				t.Parallel()
+				wantEsc := fmt.Sprintf(`\u{%x}`, r)
+				if got := EscapeString(string(r)); got != wantEsc {
+					t.Errorf("as first: got %q, want %q", got, wantEsc)
+				}
+				if got := EscapeString("a" + string(r)); got != "a"+wantEsc {
+					t.Errorf("in continuation: got %q, want %q", got, "a"+wantEsc)
+				}
+			})
+		}
+	})
+
+	// isPrintable must match Rust's is_printable() lookup tables.
+	t.Run("isPrintable", func(t *testing.T) {
+		t.Parallel()
+		tests := []struct {
+			r    rune
+			want bool
+		}{
+			// ASCII
+			{0x00, false}, {0x1f, false}, {0x20, true}, {0x7e, true}, {0x7f, false},
+			// C1 controls
+			{0x80, false}, {0x85, false}, {0x9f, false},
+			// BMP specials
+			{0xa0, false}, {0xa1, true}, {0xad, false}, {0xae, true}, {0xe9, true},
+			{0x0300, true}, {0x0378, false}, {0x0903, true},
+			{0x200c, false}, {0x200d, false}, {0x20dd, true}, {0xff9e, true}, {0xfffe, false},
+			// SMP
+			{0x10000, true}, {0x1f600, true}, {0x1000c, false}, {0x10100, true},
+			// Supplementary — hardcoded ranges
+			{0x20000, true},
+			{0x2a6e0, false}, {0x2b81e, false}, {0x2ceae, false},
+			{0x2ebe1, false}, {0x2ee5e, false}, {0x2fa1e, false},
+			{0x3134b, false}, {0x3347a, false}, {0xe01f0, false},
+			{0xe0100, true},
+		}
+		for _, tc := range tests {
+			t.Run(fmt.Sprintf("U+%04X", tc.r), func(t *testing.T) {
+				t.Parallel()
+				if got := isPrintable(tc.r); got != tc.want {
+					t.Errorf("got %v, want %v", got, tc.want)
+				}
+			})
+		}
+	})
+
+	// isGraphemeExtended must match Unicode Grapheme_Extend = Mn + Me + Other_Grapheme_Extend.
+	t.Run("isGraphemeExtended", func(t *testing.T) {
+		t.Parallel()
+		tests := []struct {
+			r    rune
+			want bool
+		}{
+			{'A', false}, {0x01, false},
+			{0x0300, true}, {0x0301, true}, // Mn
+			{0x0488, true}, {0x1ABE, true}, {0x20DD, true}, // Me
+			{0x0903, false}, {0x093E, false}, // Mc only
+			{0x200C, true},                 // Other_Grapheme_Extend
+			{0x200D, false},                // Join_Control, NOT Grapheme_Extend
+			{0xFF9E, true}, {0xFF9F, true}, // Other_Grapheme_Extend
+		}
+		for _, tc := range tests {
+			t.Run(fmt.Sprintf("U+%04X", tc.r), func(t *testing.T) {
+				t.Parallel()
+				if got := isGraphemeExtended(tc.r); got != tc.want {
+					t.Errorf("got %v, want %v", got, tc.want)
+				}
+			})
+		}
+	})
+
+	// Round-trip: EscapeString/EscapeCharAll → Unquote must recover the original.
+	t.Run("round_trip", func(t *testing.T) {
+		t.Parallel()
+		inputs := []string{
+			"", "hello", "a\tb\nc\r\x00", "a'b\"c\\d",
+			"a\u0300b", "\u0300a", "a\u0300\u0301",
+			"\u0903", "a\uFF9Eb", "\u20DDa",
+			string([]rune{0x01, 0x7f, 0x80, 0x9f}),
+			"\u00ad", "\u200c\u200d", "\ufffe",
+			"\U0001F600", "\U00010000",
+			string([]rune{0x0300, 'a', 0xFF9E, 'b', 0x20DD}),
+			string([]rune{0xa0, 0xa1, 0xad, 0xae, 0xbf}),
+			string([]rune{0x200b, 0x200c, 0x200d, 0x200e, 0x200f}),
+			string([]rune{0xe0001, 0xe0020, 0xe007f}),
+			// Go-style escapes that Cedar doesn't support (\a, \b, \f, \v)
+			"\a\b\f\v",
+			// All ASCII controls
+			string([]rune{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0b, 0x0c, 0x0e, 0x0f}),
+			// Mixed printable and non-printable
+			"hello\x00world\tfoo\nbar",
+		}
+		for _, in := range inputs {
+			for _, mode := range []struct {
+				name string
+				fn   func(string) string
+			}{
+				{"EscapeString", EscapeString},
+				{"EscapeCharAll", EscapeCharAll},
+			} {
+				escaped := mode.fn(in)
+				unescaped, _, err := Unquote([]byte(escaped), false)
+				if err != nil {
+					t.Errorf("%s(%q): Unquote failed: %v (escaped=%q)", mode.name, in, err, escaped)
+				} else if unescaped != in {
+					t.Errorf("%s round-trip: %q → %q → %q", mode.name, in, escaped, unescaped)
+				}
+			}
+		}
+	})
+}