里）。它与 channelbridge 侧 // sanitize_literal_breaks_test.go 的同名字面量**逐字相同** —— 那正是「网关/落库 // 与 IM 出站吃同一份文本」的断言方式（同一份样本，两侧各自断言）。 const realLiteralBreakReply = `
伊奥尼亚：G♭ A♭ B♭ C♭ D♭ E♭ F\n多利亚：G♭ A♭ B♭♭ C♭ D♭ E♭ F♭\n弗里吉亚：G♭ A♭♭ B♭♭ C♭ D♭ E♭♭ F♭\n利底亚：G♭ A♭ B♭ C D♭ E♭ F\n混合利底亚：G♭ A♭ B♭ C♭ D♭ E♭ F♭\n爱奥利亚：G♭ A♭ B♭♭ C♭ D♭ E♭♭ F♭\n洛克里亚：G♭ A♭♭ B♭♭ C♭ D♭♭ E♭♭ F♭
那些重降的等音：A♭♭=G、B♭♭=A、D♭♭=C、E♭♭=D。
不过要是题目问的是「G♭ 大调关系调式」那种，七种用的都是 G♭ A♭ B♭ C♭ D♭ E♭ F 这一组音，只是主音各站各的位置♪
` // TestRenderLiteralLineBreaks_RealMachineMessage 是必测①的**修前红/修后绿**判据： // 真机原文的 6 处字面 `\n` 全部渲染成真换行，段落结构（5 个）一字不变，且
// 绝不引入 `
`（它不是气泡分隔符，只是气泡内的换行）。
func TestRenderLiteralLineBreaks_RealMachineMessage(t *testing.T) {
t.Parallel()
got := RenderLiteralLineBreaks(realLiteralBreakReply)
if strings.Contains(got, literalEscapeSample) {
t.Fatalf("仍剩字面 `\\n` —— QQ 上还会看到「F\\n多利亚」:\n%q", got)
}
if wantGain := strings.Count(realLiteralBreakReply, literalEscapeSample); strings.Count(got, "\n")-strings.Count(realLiteralBreakReply, "\n") != wantGain {
t.Fatalf("新增真换行 = %d, want %d", strings.Count(got, "\n")-strings.Count(realLiteralBreakReply, "\n"), wantGain)
}
if n := strings.Count(got, "
"); n != 5 { t.Fatalf("
块 = %d, want 5（段落口径不得被改动）", n)
}
if strings.Contains(got, " 伊奥尼亚：G♭ A♭ B♭ C♭ D♭ E♭ F\n多利亚："
if !strings.Contains(got, scaleHead) {
t.Fatalf("调式段没有被换行渲染:\n%q", got)
}
}
// TestRenderLiteralLineBreaks_CodeFenceProtected 是必测②：围栏代码块里的 `\n`
// 逐字保留（她解释 `print("a\nb")` 时那两下是**代码内容**），围栏前后的正文照常渲染。
func TestRenderLiteralLineBreaks_CodeFenceProtected(t *testing.T) {
t.Parallel()
in := "先说明一句" + literalEscapeSample + "这里要换行。\n" +
"```go\nfmt.Print(\"a" + literalEscapeSample + "b\")\n```\n" +
"围栏之后这句" + literalEscapeSample + "也换行。"
got := RenderLiteralLineBreaks(in)
if !strings.Contains(got, `fmt.Print("a\nb")`) {
t.Fatalf("围栏内的 `\\n` 被改坏了（代码内容必须逐字保留）:\n%q", got)
}
if got := strings.Count(RenderLiteralLineBreaks(in), literalEscapeSample); got != 1 {
t.Fatalf("剩余字面 `\\n` = %d, want 1（只该剩围栏里那一处）", got)
}
for _, want := range []string{"先说明一句\n这里要换行。", "围栏之后这句\n也换行。"} {
if !strings.Contains(got, want) {
t.Fatalf("围栏外正文没有被渲染，want 含 %q:\n%q", want, got)
}
}
}
// TestRenderLiteralLineBreaks_NestedFenceRespectsOpeningRun 钉住 CommonMark 的围栏闭合
// 口径：**闭合串不得短于开启串**。四个反引号开启的围栏里嵌着三反引号的示例时，内层
// ``` 只是**代码内容**，不能把外层围栏闭合 —— 否则示例里的 `print("a\nb")` 会被渲染成
// 真换行，而这段文本紧接着就落库（改坏的代码会永久进历史）。
func TestRenderLiteralLineBreaks_NestedFenceRespectsOpeningRun(t *testing.T) {
t.Parallel()
const nested = "````markdown\n```go\nfmt.Println(\"a" + literalEscapeSample + "b\")\n```\n````"
in := "教你怎么写围栏代码块：\n\n" + nested + "\n\n围栏之后这句" + literalEscapeSample + "也换行。"
got := RenderLiteralLineBreaks(in)
if !strings.Contains(got, nested) {
t.Fatalf("嵌套围栏没有被逐字保留（内层 ``` 提前闭合了外层 ````）:\n got %q\nwant 含 %q", got, nested)
}
if strings.Contains(got, "fmt.Println(\"a\nb\")") {
t.Fatalf("嵌套围栏里的字面 `\\n` 被渲染成真换行 —— 代码内容被改坏:\n%q", got)
}
if !strings.HasSuffix(got, "围栏之后这句\n也换行。") {
t.Fatalf("围栏之外的正文没被渲染（保护不得溢出）:\n%q", got)
}
}
// TestRenderLiteralLineBreaks_InlineCodeProtected 是必测②的另一半：行内代码
// （单个反引号与两个反引号两种定界符）里的 `\n` 也不动。
func TestRenderLiteralLineBreaks_InlineCodeProtected(t *testing.T) {
t.Parallel()
in := "行内代码 `a" + literalEscapeSample + "b` 里那两下不动；真的换行这样写：" + literalEscapeSample + "下一句。"
got := RenderLiteralLineBreaks(in)
if !strings.Contains(got, "行内代码 `a"+literalEscapeSample+"b` 里那两下不动") {
t.Fatalf("行内代码里的 `\\n` 被改坏了:\n%q", got)
}
if !strings.HasSuffix(got, "真的换行这样写：\n下一句。") {
t.Fatalf("行内代码之外的 `\\n` 没被渲染:\n%q", got)
}
// 双反引号定界符同样受保护。
double := "``a" + literalEscapeSample + "b`` 不动，外面" + literalEscapeSample + "要换行"
if got := RenderLiteralLineBreaks(double); !strings.Contains(got, "``a"+literalEscapeSample+"b``") ||
!strings.HasSuffix(got, "外面\n要换行") {
t.Fatalf("双反引号行内代码处理错:\n%q", got)
}
// 落单反引号（没有等长闭合串）只是普通字符，不吞掉后面的正文。
stray := "一个孤零零的反引号 `，然后" + literalEscapeSample + "这里照常换行"
if got := RenderLiteralLineBreaks(stray); !strings.HasSuffix(got, "然后\n这里照常换行") {
t.Fatalf("落单反引号把后面的正文一并保护了（应为普通字符）:\n%q", got)
}
}
// TestRenderLiteralLineBreaks_DoubleBackslashUntouched 是必测③：`\\n`（双反斜杠 +
// n，模型讲转义规则或写路径时会写）**原样保留** —— 它的语义是一个反斜杠加字母 n。
// 顺带钉住「`\\` 之后紧跟的字面 `\n` 仍要渲染」这条配对口径。
func TestRenderLiteralLineBreaks_DoubleBackslashUntouched(t *testing.T) {
t.Parallel()
const doubleBackslash = "\\\\n" // \\n：两个反斜杠 + n
unchanged := "字面反斜杠加 n 要写成 " + doubleBackslash + " 这样"
if got := RenderLiteralLineBreaks(unchanged); got != unchanged {
t.Fatalf("`\\\\n` 被改动了:\n got %q\nwant %q", got, unchanged)
}
paired := "先一个转义的反斜杠 \\\\ 然后" + literalEscapeSample + "这里换行"
if got := RenderLiteralLineBreaks(paired); !strings.HasSuffix(got, "然后\n这里换行") {
t.Fatalf("`\\\\` 之后的字面 `\\n` 没有被渲染:\n%q", got)
}
}
// TestRenderLiteralLineBreaks_OtherEscapesUntouched 记录本层的**范围边界**：只认
// `\n` 这一个形状，`\t` / `\r` / 行尾孤立的 `\` 一律不动（其余字面转义见切片报告，
// 本片不扩大语义）。
func TestRenderLiteralLineBreaks_OtherEscapesUntouched(t *testing.T) {
t.Parallel()
for _, tc := range []struct{ name, in string }{
{"tab", "缩进" + "\\t" + "不处理"},
{"carriage", "回车" + "\\r" + "不处理"},
{"trailing-backslash", "行尾孤立的反斜杠\\"},
{"unicode", "转义" + "\\u00e9" + "不处理"},
} {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
if got := RenderLiteralLineBreaks(tc.in); got != tc.in {
t.Fatalf("%s：被本层改动了:\n got %q\nwant %q", tc.name, got, tc.in)
}
})
}
}
// TestRenderLiteralLineBreaks_UnclosedFenceProtected 是保守兜底：围栏没闭合时，
// 后面的文本**一律原样保留**（宁可少渲染一处换行，也不把可能仍是代码的正文改坏）。
func TestRenderLiteralLineBreaks_UnclosedFenceProtected(t *testing.T) {
t.Parallel()
in := "```go\n代码里的" + literalEscapeSample + "不动"
if got := RenderLiteralLineBreaks(in); got != in {
t.Fatalf("未闭合围栏之后的正文被改了:\n got %q\nwant %q", got, in)
}
}
// TestRenderLiteralLineBreaks_IdempotentAndFastPath 是守门断言：没有字面 `\n` 的
// 文本逐字返回；有的话二次调用逐字相同（它跑在每条回复的写入路径上，破掉幂等就会
// 每读改写一次叠一层）。
func TestRenderLiteralLineBreaks_IdempotentAndFastPath(t *testing.T) {
t.Parallel()
for _, plain := range []string{"", "普通一句话，没有字面转义。", " 已经规整好的段落。 "); n != 5 {
t.Fatalf(" 块 = %d, want 5", n)
}
mixed := " 甲" + literalEscapeSample + "乙 甲\n乙