523 lines
19 KiB
C
523 lines
19 KiB
C
/* test_markdown.c - 流式 Markdown 渲染器测试
|
|
*
|
|
* 最关键的不变量: 把同一段文本任意切分后逐片喂入, 输出必须与一次性喂入
|
|
* 完全一致. SSE 的分片位置是随机的, 这条不成立就会漏出"半个星号".
|
|
*/
|
|
#include "markdown.h"
|
|
#include "util.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static int failures = 0;
|
|
static int checks = 0;
|
|
|
|
#define CHECK(cond, ...) \
|
|
do { \
|
|
checks++; \
|
|
if (!(cond)) { \
|
|
failures++; \
|
|
printf(" ✗ %s:%d: ", __FILE__, __LINE__); \
|
|
printf(__VA_ARGS__); \
|
|
printf("\n"); \
|
|
} \
|
|
} while (0)
|
|
|
|
/* 去掉 ANSI 转义, 得到"肉眼可见"的文本 */
|
|
static char *strip_ansi(const char *s)
|
|
{
|
|
StrBuf out;
|
|
sb_init(&out);
|
|
for (const char *p = s; *p; ) {
|
|
if (*p == 0x1b && p[1] == '[') {
|
|
p += 2;
|
|
while (*p && !(*p >= '@' && *p <= '~')) p++;
|
|
if (*p) p++;
|
|
continue;
|
|
}
|
|
sb_putc(&out, *p++);
|
|
}
|
|
return sb_detach(&out);
|
|
}
|
|
|
|
static void show_escaped(const char *s)
|
|
{
|
|
for (const unsigned char *p = (const unsigned char *)s; *p; p++) {
|
|
if (*p == 0x1b) printf("<ESC>");
|
|
else if (*p == '\n') printf("\\n");
|
|
else putchar(*p);
|
|
}
|
|
}
|
|
|
|
/* 渲染到内存流; chunk == 0 表示一次性喂入 */
|
|
static char *do_render(const char *input, int enabled, size_t chunk)
|
|
{
|
|
char *buf = NULL;
|
|
size_t size = 0;
|
|
FILE *f = open_memstream(&buf, &size);
|
|
if (!f) return NULL;
|
|
MdRenderer *r = md_new(enabled);
|
|
md_set_out(r, f);
|
|
|
|
if (chunk == 0) {
|
|
md_feed(r, input);
|
|
} else {
|
|
size_t len = strlen(input);
|
|
for (size_t i = 0; i < len; i += chunk) {
|
|
size_t n = len - i < chunk ? len - i : chunk;
|
|
char tmp[64];
|
|
if (n >= sizeof tmp) n = sizeof tmp - 1;
|
|
memcpy(tmp, input + i, n);
|
|
tmp[n] = '\0';
|
|
md_feed(r, tmp);
|
|
}
|
|
}
|
|
md_finish(r);
|
|
md_free(r);
|
|
fclose(f);
|
|
return buf;
|
|
}
|
|
|
|
static char *render(const char *in, int enabled)
|
|
{
|
|
return do_render(in, enabled, 0);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
static void test_split_invariance(void)
|
|
{
|
|
puts("分片不变性 (一次性 / 3 字节 / 逐字节 必须一致)");
|
|
static const char *samples[] = {
|
|
"**粗体**\n",
|
|
"普通 *斜体* 文本\n",
|
|
"这是 `code` 片段\n",
|
|
"# 一级标题\n## 二级标题\n",
|
|
"```c\nint main(void) { return 0; }\n```\n",
|
|
"- 项目一\n- 项目二\n",
|
|
"> 引用内容\n",
|
|
"2 * 3 * 4 = 24\n",
|
|
"**a** 和 *b* 和 `c`\n",
|
|
"---\n",
|
|
"----\n",
|
|
"-x\n",
|
|
"--x\n",
|
|
"混合 **粗** 与 `代` 与 *斜* 一行\n",
|
|
"# 标题里有 **粗体**\n",
|
|
"```\n**这不是粗体**\n```\n",
|
|
"```\n没有闭合的代码块\n",
|
|
"未闭合 **粗体\n下一行\n",
|
|
"*a\nb*\n",
|
|
"**\n",
|
|
"***\n",
|
|
"\n\n**\n\n",
|
|
"行内 `代码` 跨分片被切断\n",
|
|
"| a | b |\n|---|---|\n| 1 | 22 |\n",
|
|
"| 名称 | 值 |\n|---|---|\n| 苹果 | 3 |\n| 香蕉 | 12 |\n",
|
|
"| 左 | 中 | 右 |\n|:---|:---:| ---:|\n| a | b | c |\n",
|
|
"见 [文档](https://example.com) 说明\n",
|
|
"这是 _斜体_ 与 foo_bar_baz\n",
|
|
"```\n# 不是标题\n[x](y)\n```\n",
|
|
"ls -la | grep foo\n",
|
|
"a | b\nc | d\n",
|
|
/* 以下三个是模糊测试找到并最小化出来的历史缺陷,
|
|
* 每个都曾让"一次性喂"与"分片喂"结果不一致, 留作回归见证 */
|
|
"1|`", /* 表格探测挂起整行 -> 行内代码被漏渲染 */
|
|
"- |", /* try_block 提前 return 跳过了列表规则 */
|
|
"s|\n-", /* 表格判断依赖分片边界 */
|
|
"| a |\n|---|\n", /* 表头+分隔行后紧跟 EOF */
|
|
"| a |\n|---|", /* 末尾无换行的表格 */
|
|
"| a | b |\n|---|---|\n| 1 | 2 |\n- 列表\n", /* 表格后紧跟列表 */
|
|
"| a |\n| b |\n| c |\n", /* 有续行但缺分隔行 */
|
|
};
|
|
for (size_t k = 0; k < sizeof samples / sizeof samples[0]; k++) {
|
|
char *whole = render(samples[k], 1);
|
|
char *by1 = do_render(samples[k], 1, 1);
|
|
char *by3 = do_render(samples[k], 1, 3);
|
|
int ok = whole && by1 && by3 &&
|
|
strcmp(whole, by1) == 0 && strcmp(whole, by3) == 0;
|
|
checks++;
|
|
if (!ok) {
|
|
failures++;
|
|
printf(" ✗ 分片不一致: [%s]\n", samples[k]);
|
|
printf(" 一次性: "); show_escaped(whole ? whole : "(null)"); printf("\n");
|
|
printf(" 逐字节: "); show_escaped(by1 ? by1 : "(null)"); printf("\n");
|
|
printf(" 3 字节: "); show_escaped(by3 ? by3 : "(null)"); printf("\n");
|
|
}
|
|
free(whole); free(by1); free(by3);
|
|
}
|
|
}
|
|
|
|
static void test_headings(void)
|
|
{
|
|
puts("标题");
|
|
char *o = render("# 一\n## 二\n### 三\n#### 四\n", 1);
|
|
CHECK(strstr(o, "\033[1;36m# 一\033[0m") != NULL, "H1 应为粗体青");
|
|
CHECK(strstr(o, "\033[1;35m## 二\033[0m") != NULL, "H2 应为粗体品红");
|
|
CHECK(strstr(o, "\033[1;34m### 三") != NULL, "H3 应为粗体蓝");
|
|
CHECK(strstr(o, "\033[1m#### 四") != NULL, "H4 应为粗体");
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "# 一\n## 二\n### 三\n#### 四\n") == 0,
|
|
"可见文本应保留 # 标记: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 不是标题的情况必须原样保留 */
|
|
o = render("#没有空格\n", 1);
|
|
CHECK(strcmp(o, "#没有空格\n") == 0, "无空格不应识别为标题: [%s]", o);
|
|
free(o);
|
|
|
|
o = render("####### 七个\n", 1);
|
|
CHECK(strstr(o, "####### 七个") != NULL, "7 个 # 不应识别为标题: [%s]", o);
|
|
free(o);
|
|
|
|
o = render("a # b\n", 1);
|
|
CHECK(strcmp(o, "a # b\n") == 0, "行中 # 应原样: [%s]", o);
|
|
free(o);
|
|
}
|
|
|
|
static void test_bold_italic(void)
|
|
{
|
|
puts("粗体 / 斜体");
|
|
char *o = render("**粗**\n", 1);
|
|
CHECK(strstr(o, "\033[1m粗\033[0m") != NULL, "粗体样式: [%s]", o);
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "粗\n") == 0, "粗体标记应被吃掉: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
o = render("*斜*\n", 1);
|
|
CHECK(strstr(o, "\033[3m斜\033[0m") != NULL, "斜体样式: [%s]", o);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "斜\n") == 0, "斜体标记应被吃掉: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 字面星号: 乘法 */
|
|
o = render("2 * 3 * 4\n", 1);
|
|
CHECK(strcmp(o, "2 * 3 * 4\n") == 0, "乘法星号应原样输出: [%s]", o);
|
|
free(o);
|
|
|
|
/* snake_case 不能被误伤 (这是不实现 _斜体_ 的原因) */
|
|
o = render("foo_bar_baz\n", 1);
|
|
CHECK(strcmp(o, "foo_bar_baz\n") == 0, "下划线标识符不应被改动: [%s]", o);
|
|
free(o);
|
|
|
|
/* 样式不应跨行泄漏 */
|
|
o = render("*a\nb\n", 1);
|
|
CHECK(strstr(o, "\033[0m\n") != NULL, "行尾应复位样式: [%s]", o);
|
|
free(o);
|
|
|
|
/* 嵌套: 粗体里的斜体 */
|
|
o = render("**粗 *斜* 粗**\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "粗 斜 粗\n") == 0, "嵌套可见文本: [%s]", vis);
|
|
free(vis); free(o);
|
|
}
|
|
|
|
static void test_code(void)
|
|
{
|
|
puts("代码");
|
|
/* 行内代码: 保留反引号 (便于复制), 内容着色 */
|
|
char *o = render("用 `ls -la` 看看\n", 1);
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "用 `ls -la` 看看\n") == 0,
|
|
"行内代码应保留反引号: [%s]", vis);
|
|
CHECK(strstr(o, "\033[36m") != NULL, "内容应着色: [%s]", o);
|
|
free(vis); free(o);
|
|
|
|
/* 围栏代码块内部不做行内解析 */
|
|
o = render("```\n**原样**\n```\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "```\n**原样**\n```\n") == 0,
|
|
"代码块内不应渲染粗体: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 带语言标识 */
|
|
o = render("```c\nx;\n```\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "```c\nx;\n```\n") == 0,
|
|
"语言标识与内容应完整保留: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 未闭合的代码块: 不能吞掉后面的内容 */
|
|
o = render("```\ncode\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "```\ncode\n") == 0, "未闭合代码块: [%s]", vis);
|
|
free(vis); free(o);
|
|
}
|
|
|
|
static void test_blocks(void)
|
|
{
|
|
puts("列表 / 引用 / 分隔线");
|
|
/* 列表标记必须保留模型输出的原始字符, 只上色, 不换成 • */
|
|
char *o = render("- 甲\n- 乙\n", 1);
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "- 甲\n- 乙\n") == 0, "列表应保留原始 - : [%s]", vis);
|
|
CHECK(strstr(o, "\033[36m-\033[0m") != NULL, "列表标记 - 应着色: [%s]", o);
|
|
CHECK(strstr(o, "•") == NULL, "不应出现非 ASCII 圆点: [%s]", o);
|
|
free(vis); free(o);
|
|
|
|
o = render("* 甲\n+ 乙\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "* 甲\n+ 乙\n") == 0, "列表应保留原始 * 和 + : [%s]", vis);
|
|
CHECK(strstr(o, "\033[36m*\033[0m") != NULL, "列表标记 * 应着色: [%s]", o);
|
|
CHECK(strstr(o, "\033[36m+\033[0m") != NULL, "列表标记 + 应着色: [%s]", o);
|
|
free(vis); free(o);
|
|
|
|
/* 表格不受影响: 仍然是框线字符 */
|
|
o = render("| a |\n|---|\n| 1 |\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strstr(vis, "┌") && strstr(vis, "│") && strstr(vis, "└"),
|
|
"表格仍用框线字符: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
o = render("> 引用\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "│ 引用\n") == 0, "引用: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
o = render("---\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "---\n") == 0, "分隔线可见文本: [%s]", vis);
|
|
CHECK(strstr(o, "\033[2m") != NULL, "分隔线应暗色: [%s]", o);
|
|
free(vis); free(o);
|
|
|
|
/* 非分隔线、非列表应原样 */
|
|
o = render("--x\n", 1);
|
|
CHECK(strcmp(o, "--x\n") == 0, "非分隔线应原样: [%s]", o);
|
|
free(o);
|
|
}
|
|
|
|
static void test_passthrough(void)
|
|
{
|
|
puts("关闭渲染时逐字节透传");
|
|
static const char *samples[] = {
|
|
"# 标题 **粗体** `code`\n",
|
|
"- 列表\n```\ncode\n```\n",
|
|
"\033 转义 中文 😀\n",
|
|
"没有换行的最后一行",
|
|
"",
|
|
};
|
|
for (size_t k = 0; k < sizeof samples / sizeof samples[0]; k++) {
|
|
char *whole = render(samples[k], 0);
|
|
char *by1 = do_render(samples[k], 0, 1);
|
|
CHECK(strcmp(whole, samples[k]) == 0,
|
|
"应完全透传: 期望 [%s] 实际 [%s]", samples[k], whole);
|
|
CHECK(strcmp(by1, samples[k]) == 0, "分片透传也应一致");
|
|
free(whole); free(by1);
|
|
}
|
|
}
|
|
|
|
static void test_fence_verbatim(void)
|
|
{
|
|
puts("围栏代码块: 全部不渲染");
|
|
/* 纯代码块: 输出里不应出现任何 ANSI 转义 */
|
|
char *o = render("```c\nint x = 1; // **不是粗体**\n```\n", 1);
|
|
CHECK(strstr(o, "\033") == NULL,
|
|
"代码块内不应有任何 ANSI 转义: [%s]", o);
|
|
CHECK(strcmp(o, "```c\nint x = 1; // **不是粗体**\n```\n") == 0,
|
|
"代码块应逐字节原样: [%s]", o);
|
|
free(o);
|
|
|
|
/* 代码块里的 # - > [ 都不能被当成语法 */
|
|
o = render("```\n# 不是标题\n- 不是列表\n> 不是引用\n[x](y)\n```\n", 1);
|
|
CHECK(strstr(o, "\033") == NULL, "代码块内不应有转义: [%s]", o);
|
|
CHECK(strstr(o, "# 不是标题") && strstr(o, "[x](y)") &&
|
|
strstr(o, "- 不是列表") && strstr(o, "> 不是引用"),
|
|
"代码块内容应完整: [%s]", o);
|
|
free(o);
|
|
|
|
/* 代码块结束之后, 普通文本要恢复渲染 */
|
|
o = render("```\nx\n```\n**加粗**\n", 1);
|
|
CHECK(strstr(o, "\033[1m加粗\033[0m") != NULL,
|
|
"代码块之后应恢复渲染: [%s]", o);
|
|
free(o);
|
|
}
|
|
|
|
static void test_inline_code_protected(void)
|
|
{
|
|
puts("行内代码内容不受行内语法影响");
|
|
char *o = render("形如 `a**b**c` 的写法\n", 1);
|
|
CHECK(strstr(o, "\033[1m") == NULL,
|
|
"行内代码内不应渲染粗体: [%s]", o);
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "形如 `a**b**c` 的写法\n") == 0,
|
|
"行内代码可见文本应原样: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
o = render("`[不是链接](x)` 和 `_不是斜体_`\n", 1);
|
|
CHECK(strstr(o, "\033[94m") == NULL, "行内代码内不应高亮 []: [%s]", o);
|
|
CHECK(strstr(o, "\033[3m") == NULL, "行内代码内不应渲染斜体: [%s]", o);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "`[不是链接](x)` 和 `_不是斜体_`\n") == 0,
|
|
"可见文本应原样: [%s]", vis);
|
|
free(vis); free(o);
|
|
}
|
|
|
|
static void test_underscore_italic(void)
|
|
{
|
|
puts("_斜体_ 与词内下划线保护");
|
|
char *o = render("这是 _斜体_ 文字\n", 1);
|
|
CHECK(strstr(o, "\033[3m斜体\033[0m") != NULL, "_斜体_ 应渲染: [%s]", o);
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "这是 斜体 文字\n") == 0, "可见文本: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 中文紧邻下划线也应生效 (非 ASCII 不算词字符) */
|
|
o = render("中文_斜体_中文\n", 1);
|
|
CHECK(strstr(o, "\033[3m斜体") != NULL, "中文紧邻应生效: [%s]", o);
|
|
free(o);
|
|
|
|
/* 关键保护: 下划线标识符不能被当成斜体 */
|
|
o = render("foo_bar_baz 和 __init__ 和 a_b_c\n", 1);
|
|
CHECK(strstr(o, "\033[3m") == NULL,
|
|
"下划线标识符不应被渲染为斜体: [%s]", o);
|
|
CHECK(strcmp(o, "foo_bar_baz 和 __init__ 和 a_b_c\n") == 0,
|
|
"标识符应逐字节保留: [%s]", o);
|
|
free(o);
|
|
}
|
|
|
|
static void test_link_bracket(void)
|
|
{
|
|
puts("链接: [] 下划线+青色高亮, 其余原样");
|
|
char *o = render("见 [文档](https://example.com/a) 说明\n", 1);
|
|
/* 这里是下划线 + 青 (SGR 4;36), 不是亮蓝. 整个项目只用 16 色范围内的
|
|
* 码, 理由见 src/markdown.c 顶部和 tools/check-colors.sh. */
|
|
CHECK(strstr(o, "\033[4;36m[文档]") != NULL,
|
|
"[链接文字] 应下划线+青色高亮: [%s]", o);
|
|
char *vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "见 [文档](https://example.com/a) 说明\n") == 0,
|
|
"可见文本应逐字节保留 (含 URL): [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 图片也是 [...], 同样只高亮方括号部分, 整段保留 */
|
|
o = render("\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "\n") == 0, "图片应保留原文: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 下标写法不应被当成链接 */
|
|
o = render("arr[i] = br[j]\n", 1);
|
|
CHECK(strstr(o, "\033[94m") == NULL, "下标不应高亮: [%s]", o);
|
|
CHECK(strcmp(o, "arr[i] = br[j]\n") == 0, "下标应原样: [%s]", o);
|
|
free(o);
|
|
}
|
|
|
|
static void test_tables(void)
|
|
{
|
|
puts("表格");
|
|
/* ASCII 表格: 逐字节比对完整边框输出 */
|
|
char *o = render("| a | b |\n|---|---|\n| 1 | 22 |\n", 1);
|
|
char *vis = strip_ansi(o);
|
|
const char *want =
|
|
"┌───┬────┐\n"
|
|
"│ a │ b │\n"
|
|
"├───┼────┤\n"
|
|
"│ 1 │ 22 │\n"
|
|
"└───┴────┘\n";
|
|
CHECK(strcmp(vis, want) == 0, "ASCII 表格:\n期望:\n%s\n实际:\n%s", want, vis);
|
|
CHECK(strstr(o, "\033[1m") != NULL, "表头应加粗: [%s]", o);
|
|
free(vis); free(o);
|
|
|
|
/* 中文列宽按 2 列计算, 边框必须对齐 */
|
|
o = render("| 名称 | 值 |\n|---|---|\n| 苹果 | 3 |\n", 1);
|
|
vis = strip_ansi(o);
|
|
const char *want2 =
|
|
"┌──────┬────┐\n"
|
|
"│ 名称 │ 值 │\n"
|
|
"├──────┼────┤\n"
|
|
"│ 苹果 │ 3 │\n"
|
|
"└──────┴────┘\n";
|
|
CHECK(strcmp(vis, want2) == 0, "中文表格:\n期望:\n%s\n实际:\n%s", want2, vis);
|
|
free(vis); free(o);
|
|
|
|
/* 对齐标记 */
|
|
o = render("| 左 | 中 | 右 |\n|:---|:---:|---:|\n| a | b | c |\n", 1);
|
|
vis = strip_ansi(o);
|
|
const char *want3 =
|
|
"┌────┬────┬────┐\n"
|
|
"│ 左 │ 中 │ 右 │\n"
|
|
"├────┼────┼────┤\n"
|
|
"│ a │ b │ c │\n"
|
|
"└────┴────┴────┘\n";
|
|
CHECK(strcmp(vis, want3) == 0, "对齐表格:\n期望:\n%s\n实际:\n%s", want3, vis);
|
|
free(vis); free(o);
|
|
|
|
/* 顶格必须写 '|'. 不带首竖线的写法按普通文本处理 ——
|
|
* 这是为保证"输出与分片方式无关"而做的取舍:
|
|
* 判断必须在行的第 0 个字节就能做出, 否则分片落在竖线之前时,
|
|
* 行的前半段已被当作普通文本输出, 结果会随分片方式而变. */
|
|
o = render("a | b\n--- | ---\n1 | 2\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strcmp(vis, "a | b\n--- | ---\n1 | 2\n") == 0,
|
|
"无首竖线应原样输出: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 首竖线前有缩进同理: 不认 */
|
|
o = render(" | a |\n |---|\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strstr(vis, "┌") == NULL, "缩进的表格不识别: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 误判防护: 普通文本里出现竖线 + 下一行是短横线, 不能当成表格 */
|
|
o = render("运行 ls |\n-\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strstr(vis, "┌") == NULL, "竖线+短横线不应误判成表格: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 单列极简表 */
|
|
o = render("| x |\n|---|\n| 1 |\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strstr(vis, "┌───┐") != NULL, "单列表格: [%s]", vis);
|
|
free(vis); free(o);
|
|
|
|
/* 没有分隔行就不是表格 */
|
|
o = render("a | b\nc | d\n", 1);
|
|
CHECK(strcmp(o, "a | b\nc | d\n") == 0, "无分隔行不应成表: [%s]", o);
|
|
free(o);
|
|
|
|
/* 单竖线的普通命令行不能被误判为表格 */
|
|
o = render("ls -la | grep foo\n", 1);
|
|
CHECK(strcmp(o, "ls -la | grep foo\n") == 0, "管道命令不应成表: [%s]", o);
|
|
free(o);
|
|
|
|
/* 表格后面紧跟普通文本, 两者都要正常 */
|
|
o = render("| a | b |\n|---|---|\n| 1 | 2 |\n后续段落 **粗体**\n", 1);
|
|
vis = strip_ansi(o);
|
|
CHECK(strstr(vis, "└───┴───┘\n后续段落 粗体\n") != NULL,
|
|
"表格后应恢复普通渲染: [%s]", vis);
|
|
free(vis); free(o);
|
|
}
|
|
|
|
static void test_long_line_bounded(void)
|
|
{
|
|
puts("超长待处理缓冲应有界");
|
|
/* 一个没有换行的超长 fence 信息行: 渲染器不能无限缓存 */
|
|
StrBuf sb;
|
|
sb_init(&sb);
|
|
sb_puts(&sb, "```");
|
|
for (int i = 0; i < 200000; i++) sb_putc(&sb, 'x');
|
|
char *o = render(sb.data, 1);
|
|
size_t n = strlen(o);
|
|
CHECK(n > 100000, "应该已经把内容吐出, 而不是无限缓存 (实际 %zu 字节)", n);
|
|
free(o);
|
|
sb_free(&sb);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
test_split_invariance();
|
|
test_headings();
|
|
test_bold_italic();
|
|
test_code();
|
|
test_blocks();
|
|
test_fence_verbatim();
|
|
test_inline_code_protected();
|
|
test_underscore_italic();
|
|
test_link_bracket();
|
|
test_tables();
|
|
test_passthrough();
|
|
test_long_line_bounded();
|
|
printf("\n%d 项检查, %d 项失败\n", checks, failures);
|
|
return failures ? 1 : 0;
|
|
}
|