AskaEth/MeowOS-SDK
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(tuku): M7 条漫模式与续读——模式一键切换/每册记忆、视口±1 懒解码、滑块跳页、册间衔接

Browse Source 
- 条漫：meow_scroll 跟手+fling，按滚动位置懒解码视口±1 页（驻留上限 4 页）；
  排版用 mr_book_meta 累加适宽高度（nav.c 纯逻辑，宿主可测）
- 模式：阅读 chrome 图标一键切翻页/条漫；每册模式与 last page 经 meow_config 持久化
  （reader.mode/page.<FNV1a64(册路径)>），重进该册恢复模式与页码
- 续读：离开/翻页/滚动停止节流落盘；书库扫描给含图册副标题追加「· 续读 Pn」
- 册间衔接：末页前进→同父目录下一含图册首页，首页后退→上一册末页；无相邻册轻提示不退出
- 跳页：chrome 内 meow_slider，目标页预解码完成后落位（2.5s 超时降级提示）
- 解码：改走 M12 预算解码 meow_img_load_file_dim；超大 PNG/BMP 先 probe 预判，
  超 40MiB 原始 RGBA 跳过并显示「图片无法显示」，12MiB 以上记 WARN（如实保留残余风险）
- 测试：新增条漫排版/跳页状态/模式续读持久化/册间边界宿主测试，以及真实 SDK 源码树上的
  阅读器集成测试（模式切换/跳页落位/续读/跨册），test/run_webtoon_tests.sh 一键运行
This commit is contained in:
AskaEth committed 2026-11-04 21:49:33 +08:00
1 parent 8cbb240931
commit ff97f3cee7
14 files changed
+2539 -93
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tuku/test/run_webtoon_tests.sh
Executable
+47
View File
@@ -0,0 +1,47 @@
#!/bin/bash
# run_webtoon_tests.sh — M7 条漫/模式/续读/跳页宿主测试（纯 C，不链 SDK、不需要设备）。
# - test_webtoon_strip：条漫排版（适宽高度/偏移表/可见窗口/未知尺寸兜底/跳页互逆）
# - test_jump_page：跳页状态机（预解码落位/超时降级/非法目标）与落位偏移映射
# - test_mode_persist：阅读模式与每册 last page 的 meow_config 持久化/坏值/写失败
# - test_cont_adjacent：册间自然序边界（首/末册/嵌套/符号链接）+ 书库续读角标
# 编译口径同 test/run_tests.sh（-I. + SDK 头，不链 meow_ui.a；配置/日志用存根）。
set -e
cd "$(dirname "$0")/.."
SDK="${MEOW_SDK_DIR:-$HOME/Proj/MeowOS-SDK/sdk}"
CFLAGS="-Wall -Wextra -O1 -I. -I$SDK"
OUT="build/host"
mkdir -p "$OUT"
gcc $CFLAGS test/test_webtoon_strip.c logic/reader/nav.c -o "$OUT/test_webtoon_strip"
"$OUT/test_webtoon_strip"
gcc $CFLAGS test/test_jump_page.c logic/reader/nav.c -o "$OUT/test_jump_page"
"$OUT/test_jump_page"
gcc $CFLAGS test/test_mode_persist.c logic/reader.c test/settings_reader_stub.c \
-o "$OUT/test_mode_persist"
"$OUT/test_mode_persist"
gcc $CFLAGS test/test_cont_adjacent.c logic/library.c logic/reader.c \
test/settings_reader_stub.c -o "$OUT/test_cont_adjacent"
"$OUT/test_cont_adjacent"
# 可选：真实 SDK 源码树上的阅读器集成测试（模式切换/续读/跳页/册间衔接）。
# 只发布 meow_ui.a 的交付环境自动 SKIP（与 test/run_tests.sh 的 settings_lock_host 同口径）。
if [ -f "$SDK/meow_ui_view.c" ] && [ -f "$SDK/meow_ui_config.c" ]; then
gcc $CFLAGS -DMEOW_UI_HOST_TEST -DMR_READER_HOST_TEST -I"$SDK/include" \
test/test_mode_switch_host.c ui/reader/reader.c \
logic/library.c logic/reader.c logic/reader/page_source.c logic/reader/nav.c \
"$SDK"/meow_ui_gfx.c "$SDK"/meow_ui_sys.c "$SDK"/meow_ui_theme.c \
"$SDK"/meow_ui_vol.c "$SDK"/meow_ui_log.c "$SDK"/meow_ui_widget.c \
"$SDK"/meow_ui_input.c "$SDK"/meow_ui_activity.c "$SDK"/meow_ui_dialog.c \
"$SDK"/meow_ui_ime.c "$SDK"/meow_ui_str.c "$SDK"/meow_pinyin.c \
"$SDK"/meow_ui_draw.c "$SDK"/meow_ui_view.c "$SDK"/meow_ui_box.c \
"$SDK"/meow_ui_anim.c "$SDK"/meow_ui_scroll.c "$SDK"/meow_ui_img.c \
"$SDK"/meow_ui_media.c "$SDK"/meow_notify_ipc.c "$SDK"/meow_ui_config.c \
"$SDK"/meow_ui_nav.c "$SDK"/stb_image.c "$SDK"/test_host_stub.c \
-pthread -lm -o "$OUT/test_mode_switch_host"
"$OUT/test_mode_switch_host"
else
echo "SKIP test_mode_switch_host: SDK 源码树不可用（只发布 meow_ui.a 的环境）"
fi
tuku/test/test_cont_adjacent.c
+249
View File
@@ -0,0 +1,249 @@
/* test_cont_adjacent.c — 册间顺序边界 + 书库续读角标宿主测试（无 SDK/硬件）。
*
* 覆盖：
* A1 「直接含图」判定：含图目录=书；只有子目录含图/空目录/仅非图文件=不是书；
* A2 兄弟册排序：同父目录、书库自然序（vol2 < vol10）；首/末册无相邻返回 0；
* A3 边界：末页前进→下一册、首页后退→上一册（调用方语义）；路径末尾斜杠等价；
* A4 排除：隐藏/系统目录、符号链接、普通文件不参与兄弟册；
* A5 参数：delta 非 ±1、NULL/小缓冲、不存在的目录；
* A6 书库扫描接线：有续读记录的册，行副标题出现「· 续读 Pn」角标。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_cont_adjacent.c logic/library.c logic/reader.c \
* test/settings_reader_stub.c -o test/test_cont_adjacent
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/library.h"
#include "logic/reader.h"
#include "test/settings_reader_stub.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
static int mkdir_p(const char *path)
{
char tmp[MR_PATH_MAX];
snprintf(tmp, sizeof tmp, "%s", path);
for (size_t i = 1; i <= strlen(tmp); i++) {
if (tmp[i] == '/' || tmp[i] == '\0') {
char ch = tmp[i];
tmp[i] = '\0';
if (mkdir(tmp, 0755) != 0) {
struct stat st;
if (stat(tmp, &st) != 0 || !S_ISDIR(st.st_mode)) return -1;
}
tmp[i] = ch;
}
}
return 0;
}
static int touch_file(const char *path)
{
FILE *f = fopen(path, "wb");
if (!f) return -1;
int ok = fwrite("x", 1, 1, f) == 1;
fclose(f);
return ok ? 0 : -1;
}
static int rm_rf(const char *path)
{
struct stat st;
if (lstat(path, &st) != 0) return -1;
if (!S_ISDIR(st.st_mode)) return unlink(path);
DIR *d = opendir(path);
if (!d) return -1;
struct dirent *de;
while ((de = readdir(d)) != NULL) {
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
char full[MR_PATH_MAX];
snprintf(full, sizeof full, "%s/%s", path, de->d_name);
rm_rf(full);
}
closedir(d);
return rmdir(path);
}
static void joinp(char *out, int outsz, const char *a, const char *b)
{
snprintf(out, (size_t)outsz, "%s/%s", a, b);
}
static void test_has_images(const char *root)
{
char p[MR_PATH_MAX];
CHECK(mr_library_dir_has_images(root) == 1,
"root has a loose image file (scan/adjacency only treats subdirs as books)");
joinp(p, sizeof p, root, "vol1");
CHECK(mr_library_dir_has_images(p) == 1, "vol1 is a book");
joinp(p, sizeof p, root, "dirs_only");
CHECK(mr_library_dir_has_images(p) == 0, "dirs_only is not a book");
joinp(p, sizeof p, root, "empty");
CHECK(mr_library_dir_has_images(p) == 0, "empty is not a book");
joinp(p, sizeof p, root, "txonly");
CHECK(mr_library_dir_has_images(p) == 0, "text-only dir is not a book");
CHECK(mr_library_dir_has_images("/no/such/dir/xyz") == 0, "missing dir");
CHECK(mr_library_dir_has_images(NULL) == 0 && mr_library_dir_has_images("") == 0,
"NULL/empty safe");
}
static void expect_neighbor(const char *dir, int delta, const char *want, const char *tag)
{
char out[MR_PATH_MAX];
int r = mr_book_adjacent(dir, delta, out, (int)sizeof out);
if (!want) {
CHECK(r == 0 && out[0] == '\0', "%s: no neighbor (r=%d out=%s)", tag, r, out);
} else {
CHECK(r == 1 && strcmp(out, want) == 0, "%s: got %s (want %s)", tag, out, want);
}
}
static void test_adjacent(const char *root)
{
char vol1[MR_PATH_MAX], vol2[MR_PATH_MAX], vol10[MR_PATH_MAX];
char series_a[MR_PATH_MAX], series_b[MR_PATH_MAX];
char dirs_only[MR_PATH_MAX], out[MR_PATH_MAX];
joinp(vol1, sizeof vol1, root, "vol1");
joinp(vol2, sizeof vol2, root, "vol2");
joinp(vol10, sizeof vol10, root, "vol10");
joinp(series_a, sizeof series_a, root, "series/a");
joinp(series_b, sizeof series_b, root, "series/b");
joinp(dirs_only, sizeof dirs_only, root, "dirs_only");
/* 自然序：vol1 < vol2 < vol10（vol0 是符号链接，不参与） */
expect_neighbor(vol1, 1, vol2, "vol1 next");
expect_neighbor(vol2, 1, vol10, "vol2 next");
expect_neighbor(vol10, 1, NULL, "vol10 next (end)");
expect_neighbor(vol1, -1, NULL, "vol1 prev (start)");
expect_neighbor(vol2, -1, vol1, "vol2 prev");
expect_neighbor(vol10, -1, vol2, "vol10 prev");
/* 末尾斜杠等价 */
char slash[MR_PATH_MAX];
snprintf(slash, sizeof slash, "%s/", vol2);
expect_neighbor(slash, 1, vol10, "trailing slash next");
expect_neighbor(slash, -1, vol1, "trailing slash prev");
/* 嵌套父目录：series/a <-> series/b */
expect_neighbor(series_a, 1, series_b, "series a next");
expect_neighbor(series_b, -1, series_a, "series b prev");
expect_neighbor(series_b, 1, NULL, "series b next (end)");
/* 不是书的目录：不在兄弟表中 */
expect_neighbor(dirs_only, 1, NULL, "dirs_only not a book");
expect_neighbor(dirs_only, -1, NULL, "dirs_only not a book prev");
/* 路径参数：delta/缓冲/不存在 */
CHECK(mr_book_adjacent(vol1, 0, out, (int)sizeof out) == -1, "delta 0 invalid");
CHECK(mr_book_adjacent(vol1, 2, out, (int)sizeof out) == -1, "delta 2 invalid");
CHECK(mr_book_adjacent(vol1, -2, out, (int)sizeof out) == -1, "delta -2 invalid");
CHECK(mr_book_adjacent(NULL, 1, out, (int)sizeof out) == -1, "NULL dir");
CHECK(mr_book_adjacent(vol1, 1, NULL, 32) == -1, "NULL out");
CHECK(mr_book_adjacent(vol1, 1, out, 4) == 0, "small out -> no fit (0)");
CHECK(mr_book_adjacent("/no/such/book", 1, out, (int)sizeof out) == 0,
"missing parent -> 0");
CHECK(mr_book_adjacent("/", 1, out, (int)sizeof out) == -1, "root path invalid");
}
static void test_library_badge(const char *root)
{
mr_test_cfg_clear();
char vol1[MR_PATH_MAX], vol2[MR_PATH_MAX];
joinp(vol1, sizeof vol1, root, "vol1");
joinp(vol2, sizeof vol2, root, "vol2");
/* vol1 有续读记录（第 5 页），vol2 没有 */
mr_cont_save(vol1, 4, MR_MODE_WEBTOON);
mr_library lib;
memset(&lib, 0, sizeof lib);
int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
CHECK(n > 0, "library scan n=%d", n);
int seen1 = 0, seen2 = 0;
for (int i = 0; i < lib.count; i++) {
mr_library_entry *e = &lib.items[i];
if (strcmp(e->name, "vol1") == 0) {
seen1 = 1;
CHECK(strstr(e->subtitle, "续读 P5") != NULL, "vol1 subtitle=%s", e->subtitle);
CHECK(strstr(e->subtitle, "page") != NULL, "vol1 keeps pages text: %s", e->subtitle);
}
if (strcmp(e->name, "vol2") == 0) {
seen2 = 1;
CHECK(strstr(e->subtitle, "续读") == NULL, "vol2 no badge: %s", e->subtitle);
CHECK(strcmp(e->subtitle, "1 page") == 0, "vol2 subtitle=%s", e->subtitle);
}
}
CHECK(seen1 == 1, "vol1 listed");
CHECK(seen2 == 1, "vol2 listed");
mr_library_free(&lib);
/* 记录清除后角标消失 */
mr_cont_save(vol1, 0, MR_MODE_WEBTOON);
memset(&lib, 0, sizeof lib);
CHECK(mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH) > 0, "rescan");
for (int i = 0; i < lib.count; i++)
if (strcmp(lib.items[i].name, "vol1") == 0)
CHECK(strstr(lib.items[i].subtitle, "续读") == NULL, "cleared badge gone");
mr_library_free(&lib);
}
int main(void)
{
char tmpl[] = "./mr_cont_adj_XXXXXX";
char *root = mkdtemp(tmpl);
CHECK(root != NULL, "mkdtemp");
if (!root) return 1;
char p[MR_PATH_MAX];
const char *books[] = { "vol1", "vol2", "vol10", "series/a", "series/b", "dirs_only/inside" };
for (unsigned i = 0; i < sizeof books / sizeof books[0]; i++) {
joinp(p, sizeof p, root, books[i]);
CHECK(mkdir_p(p) == 0, "mkdir %s", p);
char img[MR_PATH_MAX];
joinp(img, sizeof img, p, "001.png");
CHECK(touch_file(img) == 0, "image %s", img);
}
joinp(p, sizeof p, root, "empty");
mkdir_p(p);
joinp(p, sizeof p, root, "txonly");
mkdir_p(p);
joinp(p, sizeof p, root, "txonly/readme.txt");
touch_file(p);
joinp(p, sizeof p, root, ".hidden");
mkdir_p(p);
joinp(p, sizeof p, root, ".hidden/001.png");
touch_file(p);
joinp(p, sizeof p, root, "MeowOS");
mkdir_p(p);
joinp(p, sizeof p, root, "MeowOS/001.png");
touch_file(p);
joinp(p, sizeof p, root, "loose.png");
touch_file(p);
char vol1[MR_PATH_MAX], vol0[MR_PATH_MAX];
joinp(vol1, sizeof vol1, root, "vol1");
joinp(vol0, sizeof vol0, root, "vol0");
if (symlink(vol1, vol0) == 0) { /* 有权限才测；无权限时 symlink 失败也不影响上面的断言 */ }
test_has_images(root);
test_adjacent(root);
test_library_badge(root);
rm_rf(root);
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/test/test_jump_page.c
+140
View File
@@ -0,0 +1,140 @@
/* test_jump_page.c — 跳页状态机 + 条漫落位映射宿主测试（无 SDK/硬件）。
*
* 覆盖：
* J1 跳页状态：begin 夹取/非法取消、active/target、预解码就绪落位、超时降级落位；
* J2 落位映射：mr_strip_offset_for_page 与 page_at 互逆（首/中/末页，max 夹取）；
* J3 边界：空册/越界/重复取消；正常等待不提前落位（不白屏——没有图就不落）。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_jump_page.c logic/reader/nav.c \
* -o test/test_jump_page && ./test/test_jump_page
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/reader/nav.h"
#include <stdio.h>
#include <string.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
#define VW 480
#define VH 720
#define TIMEOUT 2500ULL
static int g_meta_w[8], g_meta_h[8], g_meta_n;
static int meta_cb(void *ctx, int i, int *w, int *h)
{
(void)ctx;
if (i < 0 || i >= g_meta_n) return 0;
*w = g_meta_w[i];
*h = g_meta_h[i];
return 1;
}
static void build_strip(mr_strip *s, int pages)
{
memset(s, 0, sizeof *s);
g_meta_n = pages;
for (int i = 0; i < pages; i++) {
g_meta_w[i] = 800;
g_meta_h[i] = 1200; /* 适宽后每页 720px */
}
CHECK(mr_strip_build(s, pages, VW, VH, meta_cb, NULL) == 0, "build strip pages=%d", pages);
}
static void test_jump_state(void)
{
mr_jump j;
memset(&j, 0, sizeof j);
CHECK(mr_jump_active(&j) == 0, "fresh inactive");
CHECK(mr_jump_target(&j) == -1, "fresh target -1");
/* 正常：开始 → 未就绪继续等 → 就绪落位 */
mr_jump_begin(&j, 4, 10, 100);
CHECK(mr_jump_active(&j) == 1 && mr_jump_target(&j) == 4, "begin active target=4");
int to = -1;
CHECK(mr_jump_poll(&j, 0, 200, TIMEOUT, &to) == 0 && to == 0, "waiting no timeout");
CHECK(mr_jump_active(&j) == 1, "still active while waiting");
CHECK(mr_jump_poll(&j, 1, 300, TIMEOUT, &to) == 1 && to == 0, "ready lands");
CHECK(mr_jump_active(&j) == 0 && mr_jump_target(&j) == -1, "cleared after land");
/* 超时：仍然落位，但标记降级 */
mr_jump_begin(&j, 2, 10, 1000);
CHECK(mr_jump_poll(&j, 0, 1000 + TIMEOUT - 1, TIMEOUT, &to) == 0, "just before timeout waits");
CHECK(mr_jump_poll(&j, 0, 1000 + TIMEOUT, TIMEOUT, &to) == 1 && to == 1, "timeout lands");
CHECK(mr_jump_active(&j) == 0, "timeout clears");
/* 就绪与超时同时成立：优先算正常就绪 */
mr_jump_begin(&j, 1, 10, 0);
CHECK(mr_jump_poll(&j, 1, 999999, TIMEOUT, &to) == 1 && to == 0,
"ready wins over timeout");
/* timeout=0 表示不限时 */
mr_jump_begin(&j, 1, 10, 0);
CHECK(mr_jump_poll(&j, 0, 999999999ULL, 0, &to) == 0 && to == 0, "no timeout when 0");
/* begin 夹取/非法 */
mr_jump_begin(&j, -1, 10, 0);
CHECK(mr_jump_active(&j) == 0, "begin(-1) cancels");
mr_jump_begin(&j, 10, 10, 0);
CHECK(mr_jump_active(&j) == 0, "begin(count) cancels");
mr_jump_begin(&j, 0, 0, 0);
CHECK(mr_jump_active(&j) == 0, "begin empty book cancels");
/* 取消幂等；NULL 安全 */
mr_jump_begin(&j, 3, 10, 5);
mr_jump_cancel(&j);
mr_jump_cancel(&j);
CHECK(mr_jump_active(&j) == 0, "cancel idempotent");
CHECK(mr_jump_poll(NULL, 1, 1, TIMEOUT, &to) == 0, "poll NULL");
mr_jump_cancel(NULL);
mr_jump_begin(NULL, 0, 10, 0);
/* timed_out 可为 NULL */
mr_jump_begin(&j, 5, 10, 0);
CHECK(mr_jump_poll(&j, 0, TIMEOUT + 1, TIMEOUT, NULL) == 1, "poll NULL timed_out");
}
static void test_land_mapping(void)
{
mr_strip s;
build_strip(&s, 5);
CHECK(mr_strip_total(&s) == 3600, "total=%d", mr_strip_total(&s));
CHECK(mr_strip_max_offset(&s) == 2880, "max=%d", mr_strip_max_offset(&s));
int expect_top[5] = { 0, 720, 1440, 2160, 2880 };
for (int i = 0; i < 5; i++) {
int off = mr_strip_offset_for_page(&s, i);
CHECK(off == expect_top[i], "page %d offset %d (want %d)", i, off, expect_top[i]);
CHECK(mr_strip_page_at(&s, off) == i, "page_at(offset(%d)) == %d", i, i);
}
/* 末页顶端恰在 max（整页铺满视口），落位不会越界 */
CHECK(mr_strip_offset_for_page(&s, 4) == mr_strip_max_offset(&s), "last page == max");
/* page+1 的偏移等于 page 的末端（页间无缝） */
CHECK(mr_strip_top(&s, 1) == mr_strip_top(&s, 0) + mr_strip_page_h(&s, 0),
"page tops contiguous");
/* 跳页目标页必须在解码窗里（否则会被淘汰）：窗口只给 1 槽时也能覆盖目标 */
int f = -1, l = -1;
CHECK(mr_strip_window(&s, 0, 1, &f, &l) == 1 && f == l, "single-slot window");
mr_strip_free(&s);
/* 空册：没有可落位目标 */
mr_strip e;
memset(&e, 0, sizeof e);
CHECK(mr_strip_offset_for_page(&e, 0) == -1, "empty book no offset");
CHECK(mr_strip_page_at(&e, 0) == -1, "empty book no page");
}
int main(void)
{
test_jump_state();
test_land_mapping();
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/test/test_mode_persist.c
+165
View File
@@ -0,0 +1,165 @@
/* test_mode_persist.c — 阅读模式 + 每册续读状态持久化宿主测试（无 SDK/硬件）。
*
* 覆盖：
* P1 模式值：valid/name/parse（paged/webtoon，非法值回退）；
* P2 册标识键：reader.page/mode.<FNV1a64(规范路径)>，末尾斜杠等价、不同册不同键、
* 键字符集安全（[A-Za-z0-9._-]）；
* P3 默认值：无记录时 get_mode/get_page 返回调用方给的默认值；
* P4 读写往返 + 册间隔离 + 一次 save 写两键；
* P5 坏值/非法模式忽略（不覆盖已有记录）；写失败只 WARN 不崩；
* P6 书库角标：page>0 → "续读 Pn"；page==0/无记录 → 无角标。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_mode_persist.c logic/reader.c \
* test/settings_reader_stub.c -o test/test_mode_persist
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/reader.h"
#include "test/settings_reader_stub.h"
#include "include/meow_ui_config.h"
#include <ctype.h>
#include <stdio.h>
#include <string.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
static void test_mode_values(void)
{
CHECK(mr_mode_valid(MR_MODE_PAGED) == 1, "paged valid");
CHECK(mr_mode_valid(MR_MODE_WEBTOON) == 1, "webtoon valid");
CHECK(mr_mode_valid(-1) == 0 && mr_mode_valid(2) == 0, "invalid modes");
CHECK(strcmp(mr_mode_name(MR_MODE_PAGED), "paged") == 0, "name paged");
CHECK(strcmp(mr_mode_name(MR_MODE_WEBTOON), "webtoon") == 0, "name webtoon");
CHECK(strcmp(mr_mode_name(99), "paged") == 0, "name invalid -> paged");
CHECK(mr_mode_parse("paged") == MR_MODE_PAGED, "parse paged");
CHECK(mr_mode_parse("webtoon") == MR_MODE_WEBTOON, "parse webtoon");
CHECK(mr_mode_parse("WEBTOON") == -1, "parse case sensitive");
CHECK(mr_mode_parse("") == -1 && mr_mode_parse(NULL) == -1, "parse empty/NULL");
}
static void test_keys(void)
{
char a[64], b[64], c[64];
CHECK(mr_cont_key("/sd/book1", "page", a, (int)sizeof a) == 0, "key ok");
CHECK(strncmp(a, "reader.page.", 12) == 0, "key prefix %s", a);
CHECK(strlen(a) == 12 + 16, "key len=%zu", strlen(a));
for (size_t i = 12; i < strlen(a); i++)
CHECK(isxdigit((unsigned char)a[i]) != 0, "key hex char");
CHECK(mr_cont_key("/sd/book1/", "page", b, (int)sizeof b) == 0, "key trailing slash");
CHECK(strcmp(a, b) == 0, "trailing slash normalizes: %s vs %s", a, b);
CHECK(mr_cont_key("/sd/book1", "mode", c, (int)sizeof c) == 0, "mode key");
CHECK(strncmp(c, "reader.mode.", 12) == 0, "mode prefix %s", c);
CHECK(strcmp(a, c) != 0, "field differs");
CHECK(mr_cont_key("/sd/book2", "page", c, (int)sizeof c) == 0, "book2 key");
CHECK(strcmp(a, c) != 0, "different books differ");
/* 参数/缓冲边界 */
CHECK(mr_cont_key(NULL, "page", a, (int)sizeof a) == -1, "NULL dir");
CHECK(mr_cont_key("", "page", a, (int)sizeof a) == -1, "empty dir");
CHECK(mr_cont_key("/a", NULL, a, (int)sizeof a) == -1, "NULL field");
CHECK(mr_cont_key("/a", "page", NULL, 32) == -1, "NULL out");
CHECK(mr_cont_key("/a", "page", a, 8) == -1 && a[0] == '\0', "small out");
}
static void test_defaults_and_roundtrip(void)
{
mr_test_cfg_clear();
CHECK(mr_cont_get_mode("/sd/a", MR_MODE_PAGED) == MR_MODE_PAGED, "default paged");
CHECK(mr_cont_get_mode("/sd/a", MR_MODE_WEBTOON) == MR_MODE_WEBTOON, "default param used");
CHECK(mr_cont_get_page("/sd/a", 0) == 0, "default page 0");
CHECK(mr_cont_get_page("/sd/a", 7) == 7, "default page param");
CHECK(mr_cont_badge("/sd/a", NULL, 0) == 0, "badge NULL safe");
char badge[24];
CHECK(mr_cont_badge("/sd/a", badge, (int)sizeof badge) == 0 && badge[0] == '\0',
"no record -> no badge");
mr_cont_set_mode("/sd/a", MR_MODE_WEBTOON);
CHECK(mr_cont_get_mode("/sd/a", MR_MODE_PAGED) == MR_MODE_WEBTOON, "mode roundtrip");
CHECK(mr_cont_get_mode("/sd/b", MR_MODE_PAGED) == MR_MODE_PAGED, "mode isolated per book");
mr_cont_set_page("/sd/a", 17);
CHECK(mr_cont_get_page("/sd/a", -1) == 17, "page roundtrip");
CHECK(mr_cont_get_page("/sd/b", -1) == -1, "page isolated per book");
CHECK(mr_cont_badge("/sd/a", badge, (int)sizeof badge) == 1, "badge shown");
CHECK(strcmp(badge, "续读 P18") == 0, "badge text %s", badge);
/* 一次 save 两键（模式 + 页码） */
mr_cont_save("/sd/c", 3, MR_MODE_WEBTOON);
CHECK(mr_cont_get_page("/sd/c", -1) == 3, "save page");
CHECK(mr_cont_get_mode("/sd/c", MR_MODE_PAGED) == MR_MODE_WEBTOON, "save mode");
CHECK(mr_cont_badge("/sd/c", badge, (int)sizeof badge) == 1 &&
strcmp(badge, "续读 P4") == 0, "save badge %s", badge);
/* page 0 视为「没有进度」，不出角标 */
mr_cont_save("/sd/d", 0, MR_MODE_PAGED);
CHECK(mr_cont_badge("/sd/d", badge, (int)sizeof badge) == 0 && badge[0] == '\0',
"page 0 -> no badge");
/* NULL/空路径安全 */
mr_cont_set_page(NULL, 5);
mr_cont_set_mode(NULL, MR_MODE_WEBTOON);
mr_cont_save(NULL, 1, 1);
mr_cont_save("", 1, 1);
CHECK(mr_cont_get_page(NULL, 9) == 9 && mr_cont_get_mode(NULL, MR_MODE_PAGED) == MR_MODE_PAGED,
"NULL dir safe");
}
static void test_bad_values(void)
{
mr_test_cfg_clear();
char key[64];
char buf[24];
/* 坏模式值 → 默认；坏页码（负数/非数字/超上限）→ 默认 */
CHECK(mr_cont_key("/sd/x", "mode", key, (int)sizeof key) == 0, "bad key");
mr_test_cfg_put(key, "vertical");
CHECK(mr_cont_get_mode("/sd/x", MR_MODE_PAGED) == MR_MODE_PAGED, "bad mode -> def");
CHECK(mr_cont_key("/sd/x", "page", key, (int)sizeof key) == 0, "bad page key");
mr_test_cfg_put(key, "-3");
CHECK(mr_cont_get_page("/sd/x", 11) == 11, "negative page -> def");
mr_test_cfg_put(key, "abc");
CHECK(mr_cont_get_page("/sd/x", 12) == 12, "non-numeric page -> def");
mr_test_cfg_put(key, "99999999");
CHECK(mr_cont_get_page("/sd/x", 13) == 13, "too-large page -> def");
mr_test_cfg_put(key, "0");
CHECK(mr_cont_get_page("/sd/x", 14) == 0, "zero page readable");
/* 非法模式值不覆盖已有记录 */
mr_cont_set_mode("/sd/y", MR_MODE_WEBTOON);
mr_cont_set_mode("/sd/y", 42);
CHECK(mr_cont_get_mode("/sd/y", MR_MODE_PAGED) == MR_MODE_WEBTOON, "invalid set ignored");
/* 写失败：只告警，内存保持旧值；不崩 */
mr_cont_save("/sd/z", 5, MR_MODE_PAGED);
int warns = mr_test_log_warns();
mr_test_cfg_fail_writes(1);
mr_cont_set_page("/sd/z", 9);
mr_cont_set_mode("/sd/z", MR_MODE_WEBTOON);
mr_cont_save("/sd/z", 10, MR_MODE_WEBTOON);
CHECK(mr_test_log_warns() > warns, "write failure warns (warns=%d)", mr_test_log_warns());
CHECK(mr_cont_get_page("/sd/z", -1) == 5, "failed write keeps old page");
CHECK(mr_cont_get_mode("/sd/z", MR_MODE_PAGED) == MR_MODE_PAGED, "failed write keeps old mode");
mr_test_cfg_fail_writes(0);
/* 写入后读回同一字符串（便于排查：paged/webtoon 明文） */
CHECK(mr_cont_key("/sd/y", "mode", key, (int)sizeof key) == 0, "read mode key");
CHECK(mr_test_cfg_get(key, buf, (int)sizeof buf) == 1 && strcmp(buf, "webtoon") == 0,
"stored mode string %s", buf);
}
int main(void)
{
test_mode_values();
test_keys();
test_defaults_and_roundtrip();
test_bad_values();
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}
tuku/test/test_mode_switch_host.c
+273
View File
@@ -0,0 +1,273 @@
/* test_mode_switch_host.c — 阅读器模式/续读/跳页/册间衔接的宿主集成测试（可选，需 SDK 源码树）。
*
* 只做纯逻辑测试覆盖不到的接缝：真实 SDK view/activity/widget + 真实图片解码 + 真实
* meow_scroll/meow_anim 节拍。用 40x60 BMP 当页图（stb 可解，无外部依赖），在临时目录
* 建两本相邻册，然后模拟用户操作：
* H1 进入：默认翻页模式、页码 0、控件归属 ACT_READER（顶栏在 on_enter 建）；
* H2 chrome 图标一键切模式：翻页 ⇄ 条漫，切换立即写 meow_config（每册记忆）；
* H3 跳页滑块：展开 → 拖到末页 → 目标页解码完成后落位（不是先白屏再跳）；
* H4 离开/重进：恢复上次页 + 模式（续读）；
* H5 册间衔接：条漫末页上拉 → 下一册首页；首页下拉 → 上一册末页；首册再无上一册时
* 停在原地（不退出、不崩）。
*
* 编译：test/run_webtoon_tests.sh（需 SDK 源码树；只发布 meow_ui.a 时自动 SKIP）。
*/
#include "tuku_internal.h"
#include "ui/reader/reader.h"
#include "include/meow_ui_anim.h"
#include "meow_ui_internal.h" /* MEOW_EV_TAP / MEOW_EV_SWIPE（宿主测试内部头） */
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int g_fail;
#define CHECK(cond, ...) do { \
if (cond) { printf(" PASS\n"); } \
else { g_fail++; printf(" FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
/* app.c 的导航上报在测试里不需要网络侧实现。 */
void mr_nav_report(void) {}
static int g_lib_enters;
static void lib_enter(meow_view *v, void *c) { (void)v; (void)c; g_lib_enters++; }
static void lib_leave(meow_view *v, void *c) { (void)v; (void)c; }
/* ---- 临时目录 + 最小 BMP24（stb 可解） ---- */
static void put16(unsigned char *p, unsigned v) { p[0] = (unsigned char)v; p[1] = (unsigned char)(v >> 8); }
static void put32(unsigned char *p, unsigned v)
{
p[0] = (unsigned char)v; p[1] = (unsigned char)(v >> 8);
p[2] = (unsigned char)(v >> 16); p[3] = (unsigned char)(v >> 24);
}
static int write_bmp24(const char *path, int w, int h)
{
int stride = ((w * 3 + 3) / 4) * 4;
int imgsz = stride * h;
unsigned char fh[14] = { 0 }, ih[40] = { 0 };
fh[0] = 'B'; fh[1] = 'M';
put32(fh + 2, (unsigned)(54 + imgsz));
put32(fh + 10, 54);
put32(ih + 0, 40);
put32(ih + 4, (unsigned)w);
put32(ih + 8, (unsigned)h);
put16(ih + 12, 1);
put16(ih + 14, 24);
put32(ih + 20, (unsigned)imgsz);
FILE *f = fopen(path, "wb");
if (!f) return -1;
int ok = fwrite(fh, 1, sizeof fh, f) == sizeof fh &&
fwrite(ih, 1, sizeof ih, f) == sizeof ih;
unsigned char *row = (unsigned char *)calloc(1, (size_t)stride);
if (!row) ok = 0;
for (int y = 0; ok && y < h; y++)
if (fwrite(row, 1, (size_t)stride, f) != (size_t)stride) ok = 0;
free(row);
if (fclose(f) != 0) ok = 0;
return ok ? 0 : -1;
}
static int mkdir_p(const char *path)
{
char tmp[MR_PATH_MAX];
snprintf(tmp, sizeof tmp, "%s", path);
for (size_t i = 1; i <= strlen(tmp); i++) {
if (tmp[i] == '/' || tmp[i] == '\0') {
char ch = tmp[i];
tmp[i] = '\0';
if (mkdir(tmp, 0755) != 0) {
struct stat st;
if (stat(tmp, &st) != 0 || !S_ISDIR(st.st_mode)) return -1;
}
tmp[i] = ch;
}
}
return 0;
}
static int rm_rf(const char *path)
{
struct stat st;
if (lstat(path, &st) != 0) return -1;
if (!S_ISDIR(st.st_mode)) return unlink(path);
DIR *d = opendir(path);
if (!d) return -1;
struct dirent *de;
while ((de = readdir(d)) != NULL) {
if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
char full[MR_PATH_MAX];
snprintf(full, sizeof full, "%s/%s", path, de->d_name);
rm_rf(full);
}
closedir(d);
return rmdir(path);
}
/* 驱动 SDK 动画节拍（宿主没有 meow_ui_run 主循环）。 */
static void pump_ms(int ms)
{
for (int i = 0; i < ms / 10; i++) {
usleep(10 * 1000);
meow_anim_tick();
}
}
/* 模拟 app.c 的点击路由：on_touch_down → on_tap（阅读页 tap 不在 view on_event 里）。 */
static int tap(int x, int y)
{
reader_on_touch_down(x, y);
reader_on_tap(x, y);
return 1;
}
static int swipe(int dir, int dist)
{
return meow_view_dispatch_event(MEOW_EV_SWIPE, dir, dist);
}
int main(void)
{
const char *base = getenv("TMPDIR");
if (!base || !base[0]) base = ".";
char tmpl[512];
snprintf(tmpl, sizeof tmpl, "%s/mr_mode_host_XXXXXX", base);
char *data = mkdtemp(tmpl);
if (!data) { printf("SKIP: mkdtemp failed\n"); return 0; }
setenv("MEOW_DATA_DIR", data, 1);
char root[MR_PATH_MAX], book1[MR_PATH_MAX], book2[MR_PATH_MAX];
snprintf(root, sizeof root, "./mr_mode_books_%ld", (long)getpid());
snprintf(book1, sizeof book1, "%s/vol1", root);
snprintf(book2, sizeof book2, "%s/vol2", root);
mkdir_p(book1);
mkdir_p(book2);
for (int b = 0; b < 2; b++) {
const char *dir = b ? book2 : book1;
for (int i = 0; i < 3; i++) {
char p[MR_PATH_MAX];
snprintf(p, sizeof p, "%s/p%d.bmp", dir, i + 1);
if (write_bmp24(p, 40, 60) != 0) { printf("SKIP: bmp write failed\n"); return 0; }
}
}
meow_ui_opts o = { 480, 720 };
if (meow_ui_init(&o) != 0) { printf("SKIP: meow_ui_init failed (no host backend)\n"); return 0; }
static const meow_view_hooks lh = { .on_enter = lib_enter, .on_leave = lib_leave };
meow_view *lib = meow_view_create(ACT_LIBRARY, MEOW_VIEW_ACTIVITY, &lh, NULL);
meow_view *reader = reader_view_create();
meow_view_page_push(ACT_LIBRARY);
/* TopAppBar 动作格（位图）：右起每格 48px；动作 0=模式 / 1=跳页 / 2=fit。 */
int w = meow_ui_width();
int mode_x = w - 10 - 48 * 3 + 24;
int jump_x = w - 10 - 48 * 2 + 24;
int bar_y = 28;
int slider_y = 56 + 4 + 20;
int sx = 24, sw = w - 48;
/* ---- H1 进入：翻页模式、第 1 页 ---- */
mr_reader_open_dir(book1);
CHECK(meow_ui_activity_active() == ACT_READER, "reader active after open");
CHECK(mr_reader_ui_count() == 3, "book pages=%d", mr_reader_ui_count());
CHECK(mr_reader_ui_mode() == MR_MODE_PAGED, "default mode is paged");
CHECK(mr_reader_ui_page() == 0, "start at page 0");
pump_ms(300);
/* ---- H2 模式切换：chrome 图标一键切，立即持久化 ---- */
CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed");
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "switched to webtoon");
CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_WEBTOON,
"webtoon mode persisted per book");
CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed (back)");
CHECK(mr_reader_ui_mode() == MR_MODE_PAGED, "switched back to paged");
CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_PAGED, "paged mode persisted");
CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed (again)");
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "webtoon again for continuity");
/* ---- H3 跳页：滑块展开 → 拖到末页 → 预解码完成后落位 ---- */
CHECK(tap(jump_x, bar_y) == 1, "jump icon tap consumed");
CHECK(mr_reader_ui_jump_open() == 1, "slider open");
reader_on_touch_down(sx + sw, slider_y);
reader_on_tap(sx + sw, slider_y);
CHECK(mr_reader_ui_jump_open() == 0, "slider closed after pick");
CHECK(mr_reader_ui_jump_pending() == 1 || mr_reader_ui_page() == 2,
"jump pending (waiting for target decode)");
pump_ms(600);
CHECK(mr_reader_ui_jump_pending() == 0, "jump landed");
CHECK(mr_reader_ui_page() == 2, "jumped to last page (got %d)", mr_reader_ui_page());
/* ---- H4 续读：离开保存 page+mode，重进恢复 ---- */
CHECK(swipe(MEOW_SWIPE_LEFT, 200) == 0, "reader leaves back-swipe to app.c");
meow_view_page_pop();
CHECK(meow_ui_activity_active() == ACT_LIBRARY, "back to library");
CHECK(mr_cont_get_page(book1, -1) == 2, "last page saved (got %d)",
mr_cont_get_page(book1, -1));
CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_WEBTOON, "mode saved");
CHECK(g_lib_enters >= 2, "library re-entered");
mr_reader_open_dir(book1);
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "mode restored on reopen");
CHECK(mr_reader_ui_page() == 2, "page restored on reopen (got %d)", mr_reader_ui_page());
pump_ms(300);
/* ---- H5 册间衔接：条漫末页上拉 → 下一册首页 ---- */
reader_on_touch_down(240, 600);
for (int i = 1; i <= 6; i++) {
reader_on_touch_move(240, 600 - i * 40);
usleep(5 * 1000);
}
CHECK(swipe(MEOW_SWIPE_UP, 240) == 1, "webtoon up-swipe consumed");
CHECK(strcmp(mr_reader_dir(), book2) == 0, "advanced to next book (got %s)", mr_reader_dir());
CHECK(mr_reader_ui_page() == 0, "next book starts at page 0");
CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "mode carried into fresh book");
pump_ms(300);
/* 首页下拉 → 上一册末页 */
reader_on_touch_down(240, 300);
for (int i = 1; i <= 6; i++) {
reader_on_touch_move(240, 300 + i * 40);
usleep(5 * 1000);
}
CHECK(swipe(MEOW_SWIPE_DOWN, 240) == 1, "webtoon down-swipe consumed");
CHECK(strcmp(mr_reader_dir(), book1) == 0, "back to previous book (got %s)", mr_reader_dir());
CHECK(mr_reader_ui_page() == 2, "previous book lands at last page (got %d)",
mr_reader_ui_page());
pump_ms(300);
/* 跳到首页后，再往上一册：没有相邻册，停在原地并提示（不退出/不崩）。 */
CHECK(tap(jump_x, bar_y) == 1, "jump icon tap consumed (to first page)");
CHECK(mr_reader_ui_jump_open() == 1, "slider open again");
reader_on_touch_down(sx + 2, slider_y);
reader_on_tap(sx + 2, slider_y);
pump_ms(500);
CHECK(mr_reader_ui_page() == 0, "jumped to first page (got %d)", mr_reader_ui_page());
reader_on_touch_down(240, 300);
for (int i = 1; i <= 6; i++) {
reader_on_touch_move(240, 300 + i * 40);
usleep(5 * 1000);
}
CHECK(swipe(MEOW_SWIPE_DOWN, 240) == 1, "edge down-swipe consumed");
CHECK(strcmp(mr_reader_dir(), book1) == 0, "no previous book: stay put");
CHECK(meow_ui_activity_active() == ACT_READER, "no previous book: still in reader (no exit)");
/* ---- 收尾 ---- */
meow_view_page_pop();
CHECK(meow_ui_activity_active() == ACT_LIBRARY, "popped back to library");
meow_view_free(reader);
meow_view_free(lib);
meow_ui_shutdown();
rm_rf(root);
rm_rf(data);
printf("%s: %s\n", g_fail ? "FAIL" : "PASS",
g_fail ? "see failures above" : "reader mode/continuity integration checks passed");
return g_fail ? 1 : 0;
}
tuku/test/test_webtoon_strip.c
+220
View File
@@ -0,0 +1,220 @@
/* test_webtoon_strip.c — 条漫排版/滚动窗口纯逻辑宿主测试（无 SDK/硬件）。
*
* 覆盖：
* W1 单页：高度=适宽、总高、max_offset=0、窗口只有本页、顶/底同时成立；
* W2 多页：按页高累加 offsets；page_at 二分定位（页边界/末页/越界）；
* W3 可见窗口：视口±1 页；max_pages 截断；条底/条顶窗口不越界；
* W4 尺寸兜底：未知 meta → 2:3 占位；横图适宽；极端长图夹到上限；
* W5 参数/生命周期：空册、非法视口、重复 free、重建；
* W6 跳页落位：offset_for_page 与 page_at 互逆（含末页 max 夹取）。
*
* 编译（在 tuku/ 下）：
* gcc -Wall -Wextra -O1 -I. test/test_webtoon_strip.c logic/reader/nav.c \
* -o test/test_webtoon_strip && ./test/test_webtoon_strip
* 或 test/run_webtoon_tests.sh。
*/
#include "logic/reader/nav.h"
#include <stdio.h>
#include <string.h>
static int g_pass, g_fail;
#define CHECK(cond, ...) do { \
if (cond) { g_pass++; } \
else { g_fail++; printf("FAIL %s:%d ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
} while (0)
#define VW 480
#define VH 720
typedef struct fake_meta {
int n;
int w[16];
int h[16];
int known[16];
} fake_meta;
static int meta_cb(void *ctx, int i, int *w, int *h)
{
fake_meta *m = (fake_meta *)ctx;
if (!m || i < 0 || i >= m->n) return 0;
*w = m->w[i];
*h = m->h[i];
return m->known[i];
}
static void meta_page(fake_meta *m, int i, int w, int h, int known)
{
m->w[i] = w;
m->h[i] = h;
m->known[i] = known;
if (i + 1 > m->n) m->n = i + 1;
}
static void test_single_page(void)
{
fake_meta m;
memset(&m, 0, sizeof m);
meta_page(&m, 0, 800, 1200, 1);
mr_strip s;
memset(&s, 0, sizeof s);
CHECK(mr_strip_build(&s, 1, VW, VH, meta_cb, &m) == 0, "build single");
CHECK(s.count == 1, "count=%d", s.count);
CHECK(mr_strip_page_h(&s, 0) == 720, "single h=%d", mr_strip_page_h(&s, 0));
CHECK(mr_strip_total(&s) == 720, "single total=%d", mr_strip_total(&s));
CHECK(mr_strip_max_offset(&s) == 0, "single max=%d", mr_strip_max_offset(&s));
CHECK(mr_strip_page_at(&s, 0) == 0, "single page at 0");
CHECK(mr_strip_page_at(&s, 719) == 0, "single page at 719");
CHECK(mr_strip_page_at(&s, 720) == 0, "single page at total clamps");
CHECK(mr_strip_at_end(&s, 0) == 1, "single at end");
CHECK(mr_strip_at_start(&s, 0) == 1, "single at start");
int f = -1, l = -1;
CHECK(mr_strip_window(&s, 0, 4, &f, &l) == 1 && f == 0 && l == 0,
"single window %d..%d", f, l);
CHECK(mr_strip_offset_for_page(&s, 0) == 0, "single offset page0");
CHECK(mr_strip_offset_for_page(&s, 9) == 0, "single offset OOB clamps");
mr_strip_free(&s);
}
static void test_multi_pages(void)
{
fake_meta m;
memset(&m, 0, sizeof m);
/* 0: 800x1200 -> 720；1: 未知 -> 720 占位；2: 横图 1500x1000 -> 320；
* 3: 方图 400x400 -> 480；4: 极端长图 1x2000 -> 夹到 200000。 */
meta_page(&m, 0, 800, 1200, 1);
meta_page(&m, 1, 0, 0, 0);
meta_page(&m, 2, 1500, 1000, 1);
meta_page(&m, 3, 400, 400, 1);
meta_page(&m, 4, 1, 2000, 1);
mr_strip s;
memset(&s, 0, sizeof s);
CHECK(mr_strip_build(&s, 5, VW, VH, meta_cb, &m) == 0, "build multi");
CHECK(mr_strip_page_h(&s, 0) == 720, "h0=%d", mr_strip_page_h(&s, 0));
CHECK(mr_strip_page_h(&s, 1) == 720, "h1(unknown)=%d", mr_strip_page_h(&s, 1));
CHECK(mr_strip_page_h(&s, 2) == 320, "h2(landscape)=%d", mr_strip_page_h(&s, 2));
CHECK(mr_strip_page_h(&s, 3) == 480, "h3(square)=%d", mr_strip_page_h(&s, 3));
CHECK(mr_strip_page_h(&s, 4) == MR_STRIP_MAX_PAGE_H, "h4(extreme)=%d",
mr_strip_page_h(&s, 4));
CHECK(mr_strip_top(&s, 0) == 0, "top0=%d", mr_strip_top(&s, 0));
CHECK(mr_strip_top(&s, 1) == 720, "top1=%d", mr_strip_top(&s, 1));
CHECK(mr_strip_top(&s, 2) == 1440, "top2=%d", mr_strip_top(&s, 2));
CHECK(mr_strip_top(&s, 3) == 1760, "top3=%d", mr_strip_top(&s, 3));
CHECK(mr_strip_top(&s, 4) == 2240, "top4=%d", mr_strip_top(&s, 4));
CHECK(mr_strip_top(&s, 5) == 202240, "top[count]=%d", mr_strip_top(&s, 5));
CHECK(mr_strip_total(&s) == 202240, "total=%d", mr_strip_total(&s));
CHECK(mr_strip_max_offset(&s) == 201520, "max=%d", mr_strip_max_offset(&s));
CHECK(mr_strip_page_at(&s, 0) == 0, "page_at 0");
CHECK(mr_strip_page_at(&s, 719) == 0, "page_at 719");
CHECK(mr_strip_page_at(&s, 720) == 1, "page_at 720");
CHECK(mr_strip_page_at(&s, 1439) == 1, "page_at 1439");
CHECK(mr_strip_page_at(&s, 1440) == 2, "page_at 1440");
CHECK(mr_strip_page_at(&s, 1759) == 2, "page_at 1759");
CHECK(mr_strip_page_at(&s, 1760) == 3, "page_at 1760");
CHECK(mr_strip_page_at(&s, 2239) == 3, "page_at 2239");
CHECK(mr_strip_page_at(&s, 2240) == 4, "page_at 2240");
CHECK(mr_strip_page_at(&s, 9999999) == 4, "page_at huge -> last");
CHECK(mr_strip_page_at(&s, -50) == 0, "page_at negative -> first");
CHECK(mr_strip_page_at(&s, 0) == 0 && mr_strip_page_at(NULL, 0) == -1, "page_at NULL");
/* 视口窗口：off=0 只看得到页 0（页 1 从 720 开始）→ ±1 = [0,1] */
int f = -1, l = -1;
CHECK(mr_strip_window(&s, 0, 4, &f, &l) == 2 && f == 0 && l == 1,
"window top %d..%d", f, l);
/* off=1000：可见页 1..2 → 窗口 [0,3] */
CHECK(mr_strip_window(&s, 1000, 4, &f, &l) == 4 && f == 0 && l == 3,
"window mid %d..%d", f, l);
/* off=max：可见页 4 → 窗口 [3,4] */
CHECK(mr_strip_window(&s, 201520, 4, &f, &l) == 2 && f == 3 && l == 4,
"window bottom %d..%d", f, l);
/* 只用 1 个槽位：窗口收缩到焦点页 */
CHECK(mr_strip_window(&s, 1000, 1, &f, &l) == 1 && f >= 1 && f <= 2 && f == l,
"window max_pages=1 %d..%d", f, l);
CHECK(mr_strip_window(&s, -100, 4, &f, &l) == 2 && f == 0 && l == 1,
"window negative off %d..%d", f, l);
CHECK(mr_strip_at_end(&s, 0) == 0, "not at end at 0");
CHECK(mr_strip_at_end(&s, 201519) == 0, "not at end just before max");
CHECK(mr_strip_at_end(&s, 201520) == 1, "at end at max");
CHECK(mr_strip_at_start(&s, 0) == 1, "at start 0");
CHECK(mr_strip_at_start(&s, 1) == 0, "not at start 1");
/* 跳页落位：每页 offset 回读一致（末页夹到 max） */
for (int i = 0; i < 5; i++) {
int off = mr_strip_offset_for_page(&s, i);
int back = mr_strip_page_at(&s, off);
CHECK(back == i, "roundtrip page %d -> off %d -> page %d", i, off, back);
}
CHECK(mr_strip_offset_for_page(&s, 4) == 2240, "last page offset = its top");
/* 短册（内容不足一屏）：任何页都夹到 max=0 */
fake_meta m2;
memset(&m2, 0, sizeof m2);
meta_page(&m2, 0, 800, 300, 1); /* 高 180 */
meta_page(&m2, 1, 800, 300, 1);
mr_strip s2;
memset(&s2, 0, sizeof s2);
CHECK(mr_strip_build(&s2, 2, VW, VH, meta_cb, &m2) == 0, "build short");
CHECK(mr_strip_total(&s2) == 360 && mr_strip_max_offset(&s2) == 0, "short totals");
CHECK(mr_strip_offset_for_page(&s2, 1) == 0, "short last page clamps to 0");
CHECK(mr_strip_at_end(&s2, 0) == 1 && mr_strip_at_start(&s2, 0) == 1, "short edges");
mr_strip_free(&s2);
/* 越界参数 */
CHECK(mr_strip_page_h(&s, -1) == 0 && mr_strip_page_h(&s, 5) == 0, "page_h OOB");
CHECK(mr_strip_top(&s, -1) == 0 && mr_strip_top(&s, 6) == 0, "top OOB");
mr_strip_free(&s);
CHECK(s.top == NULL && s.height == NULL && s.count == 0, "free clears");
mr_strip_free(&s);
}
static void test_build_contract(void)
{
fake_meta m;
memset(&m, 0, sizeof m);
meta_page(&m, 0, 800, 1200, 1);
mr_strip s;
memset(&s, 0, sizeof s);
CHECK(mr_strip_build(NULL, 1, VW, VH, meta_cb, &m) == -1, "NULL strip");
CHECK(mr_strip_build(&s, 0, VW, VH, meta_cb, &m) == -1, "count 0 -> -1");
CHECK(s.top == NULL && s.count == 0, "failed build clears");
CHECK(mr_strip_build(&s, 1, 0, VH, meta_cb, &m) == -1, "vw 0 -> -1");
CHECK(mr_strip_build(&s, 1, VW, 0, meta_cb, &m) == -1, "vh 0 -> -1");
/* meta 回调为 NULL → 全部按 2:3 占位 */
CHECK(mr_strip_build(&s, 2, VW, VH, NULL, NULL) == 0, "NULL meta build");
CHECK(mr_strip_page_h(&s, 0) == 720 && mr_strip_page_h(&s, 1) == 720,
"NULL meta fallback heights");
mr_strip_free(&s);
/* meta 返回失败（0）也按占位处理 */
CHECK(mr_strip_build(&s, 1, VW, VH, meta_cb, &m) == 0, "rebuild after free");
CHECK(mr_strip_page_h(&s, 0) == 720, "rebuild height");
mr_strip_free(&s);
/* 空排版查询全部安全 */
mr_strip e;
memset(&e, 0, sizeof e);
CHECK(mr_strip_total(&e) == 0 && mr_strip_max_offset(&e) == 0, "empty totals");
CHECK(mr_strip_page_at(&e, 0) == -1, "empty page_at");
CHECK(mr_strip_offset_for_page(&e, 0) == -1, "empty offset_for_page");
int f = 9, l = 9;
CHECK(mr_strip_window(&e, 0, 4, &f, &l) == 0 && l == -1, "empty window");
CHECK(mr_strip_at_end(&e, 0) == 0 && mr_strip_at_start(&e, 0) == 0, "empty edges");
}
int main(void)
{
test_single_page();
test_multi_pages();
test_build_contract();
printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
return g_fail ? 1 : 0;
}