333 lines
23 KiB
TypeScript
333 lines
23 KiB
TypeScript
import { describe, expect, test } from "bun:test";
|
||
import { defaultModelCapabilityConfig } from "@/lib/model-capabilities";
|
||
import { resolveImageRequestSize, validateImageSize } from "@/services/api/image-validation";
|
||
import { applyImageLayerPlanningPurpose, imageLayerOutputSize, imageLayerPlannerError, imageLayerPlanningPrompt, imageLayerPlanTargets, imageLayerTargetName, latestImageLayerPlan, parseImageLayerPlan } from "@/lib/canvas/canvas-image-layer-plan";
|
||
import type { GenerationTask } from "@/services/api/task-center";
|
||
import { supportsExperimentalLayerExtraction } from "@/lib/canvas/canvas-image-layers";
|
||
import { defaultConfig, createModelChannel, selectableModelsByCapability } from "@/stores/use-config-store";
|
||
|
||
const vision = defaultModelCapabilityConfig();
|
||
vision.text!.references.maxImages = 2;
|
||
vision.text!.references.maxImageBytes = 30 * 1024 * 1024;
|
||
const blind = defaultModelCapabilityConfig();
|
||
const image = defaultModelCapabilityConfig("km-kemei-seedream", "doubao-seedream-5-0-pro-260628");
|
||
const channel = createModelChannel({
|
||
id: "models",
|
||
models: ["visual", "blind", "editor"],
|
||
modelCosts: [
|
||
{ model: "visual", capability: "text", billingMode: "token", unitPriceMicrocredits: 1, capabilityConfig: vision },
|
||
{ model: "blind", capability: "text", billingMode: "token", unitPriceMicrocredits: 1, capabilityConfig: blind },
|
||
{ model: "editor", capability: "image", billingMode: "fixed_request", unitPriceMicrocredits: 1, capabilityConfig: image },
|
||
],
|
||
});
|
||
const config = { ...defaultConfig, channels: [channel] };
|
||
const backgroundGeneration = { prompt: "保留环境，移除已拆对象并补全遮挡", background: "opaque" };
|
||
const objectGeneration = { prompt: "只保留本层对象的原始轮廓、位置和细节", background: "transparent" };
|
||
|
||
test("默认背景前景拆分将旧副本规划转为修补背景，保留完整场景的原像素提取", () => {
|
||
const oldCopy = parseImageLayerPlan(
|
||
JSON.stringify({
|
||
canPlan: true,
|
||
layout: "composition",
|
||
layers: [
|
||
{ name: "原图底板", description: "保留原图", kind: "background", generation: backgroundGeneration, extraction: { method: "source" } },
|
||
{ name: "场景", description: "保留内部背景", kind: "object", generation: objectGeneration, editUnit: "scene", removeFromBackground: false, bbox: [100, 200, 600, 800], extraction: { method: "source-region", shape: "rect" } },
|
||
{ name: "标题", description: "标题文字", kind: "object", generation: objectGeneration, editUnit: "text", removeFromBackground: false, extraction: { method: "generate" } },
|
||
],
|
||
}),
|
||
);
|
||
const split = applyImageLayerPlanningPurpose(oldCopy, "recompose");
|
||
expect(split.layers.map((layer) => layer.removeFromBackground)).toEqual([undefined, true, true]);
|
||
expect(split.layers.map((layer) => layer.extraction?.method)).toEqual(["generate", "source-region", "generate"]);
|
||
expect(split.layers[1].extraction?.region?.bbox).toEqual([100, 200, 600, 800]);
|
||
expect(oldCopy.layers[0].extraction?.method).toBe("source");
|
||
expect(oldCopy.layers[1].removeFromBackground).toBe(false);
|
||
expect(imageLayerPlanningPrompt("自动拆分")).toContain("不是原图副本");
|
||
expect(imageLayerPlanningPrompt("自动拆分", undefined, "materials")).toContain("无需重画底板");
|
||
});
|
||
test("规划依据与编辑单元可检查；无效可选字段不破坏已有计划", () => {
|
||
const layers = [
|
||
{ name: "底图", description: "保留原图", kind: "background", generation: backgroundGeneration, extraction: { method: "source" } },
|
||
{ name: "面板", description: "完整内部场景", kind: "object", generation: objectGeneration, editUnit: "scene", removeFromBackground: false, extraction: { method: "source-region", shape: "rect" } },
|
||
];
|
||
const reasoning = { structure: "两个独立容器", editingGoal: "复用完整组件", strategy: "复制场景原像素，边界由用户框选" };
|
||
const plan = parseImageLayerPlan(JSON.stringify({ canPlan: true, layers, reasoning }));
|
||
expect(plan.reasoning).toEqual(reasoning);
|
||
expect(plan.layers[1].editUnit).toBe("scene");
|
||
expect(plan.layers[1].extraction?.method).toBe("source-region");
|
||
expect(plan.layers[1].extraction?.region).toBeUndefined();
|
||
const invalid = parseImageLayerPlan(JSON.stringify({ canPlan: true, layers: [layers[0], { ...layers[1], editUnit: "anything" }], reasoning: { structure: 8 } }));
|
||
expect(invalid.layers).toHaveLength(2);
|
||
expect(invalid.reasoning).toBeUndefined();
|
||
expect(invalid.layers[1].editUnit).toBeUndefined();
|
||
expect(invalid.warnings?.length).toBeGreaterThan(1);
|
||
});
|
||
function response(names = ["背景", "人物", "花束", "标题文字"]) {
|
||
return {
|
||
canPlan: true,
|
||
layers: names.map((name, index) => ({
|
||
name,
|
||
description: `只保留${name}，排除其他层`,
|
||
kind: index === 0 ? "background" : "object",
|
||
generation: index === 0 ? backgroundGeneration : objectGeneration,
|
||
...(index ? { bbox: [100, 200, 800, 900] } : {}),
|
||
})),
|
||
};
|
||
}
|
||
|
||
describe("通用图层规划", () => {
|
||
test("连续场景局部裁块不自动作为素材输出，不把可疑裁图改成收费重画", () => {
|
||
const layers = [
|
||
{ name: "底图", description: "原图", kind: "background", generation: backgroundGeneration, extraction: { method: "source" } },
|
||
{ name: "主要主体", description: "完整轮廓", kind: "object", generation: objectGeneration, editUnit: "object", extraction: { method: "generate" } },
|
||
{ name: "背景局部", description: "画幅内一角", kind: "object", generation: objectGeneration, editUnit: "group", bbox: [100, 100, 400, 300], extraction: { method: "source-region", shape: "rect" } },
|
||
];
|
||
const raw = parseImageLayerPlan(JSON.stringify({ canPlan: true, layout: "continuous", layers }));
|
||
const next = applyImageLayerPlanningPurpose(raw, "materials");
|
||
expect(next.layers.map((layer) => layer.name)).toEqual(["原图底板", "主要主体"]);
|
||
expect(next.warnings?.join(" ")).toContain("未自动裁成素材");
|
||
expect(applyImageLayerPlanningPurpose({ ...raw, layout: "composition" }, "materials").layers).toHaveLength(3);
|
||
expect(applyImageLayerPlanningPurpose({ ...raw, layout: "mixed" }, "materials").layers).toHaveLength(3);
|
||
expect(() => applyImageLayerPlanningPurpose({ ...raw, layers: [raw.layers[0], raw.layers[2]] }, "materials")).toThrow("没有可靠的独立素材");
|
||
});
|
||
test("素材目的纠正模型重画底板和移除项，保留区域与主体各自的提取方式", () => {
|
||
const raw = parseImageLayerPlan(
|
||
JSON.stringify({
|
||
canPlan: true,
|
||
layers: [
|
||
{ name: "底板", description: "清空内容", kind: "background", generation: backgroundGeneration, extraction: { method: "generate" } },
|
||
{
|
||
name: "完整插图",
|
||
description: "完整内部环境",
|
||
kind: "object",
|
||
generation: objectGeneration,
|
||
editUnit: "scene",
|
||
removeFromBackground: true,
|
||
bbox: [50, 150, 480, 540],
|
||
extraction: { method: "source-region", shape: "rounded-rect", radiusRatio: 0.06 },
|
||
},
|
||
{ name: "不规则主体", description: "主体轮廓", kind: "object", generation: objectGeneration, editUnit: "object", removeFromBackground: true, extraction: { method: "generate" } },
|
||
],
|
||
}),
|
||
);
|
||
const plan = applyImageLayerPlanningPurpose(raw, "materials");
|
||
expect(plan.layers[0].extraction).toEqual({ method: "source" });
|
||
expect(plan.layers[1].extraction).toEqual(raw.layers[1].extraction);
|
||
expect(plan.layers[2].extraction).toEqual({ method: "generate" });
|
||
expect(plan.layers.slice(1).every((layer) => layer.removeFromBackground === false)).toBe(true);
|
||
expect(raw.layers[0].extraction?.method).toBe("generate");
|
||
const recomposed = applyImageLayerPlanningPurpose(raw, "recompose");
|
||
expect(recomposed.layers[0].extraction?.method).toBe("generate");
|
||
expect(recomposed.layers[1].removeFromBackground).toBe(true);
|
||
});
|
||
test("完整场景分类与付费重画冲突时等待框选，不猜形状、不静默生成", () => {
|
||
for (const extraction of [undefined, { method: "generate" }]) {
|
||
const raw = parseImageLayerPlan(
|
||
JSON.stringify({
|
||
canPlan: true,
|
||
layers: [
|
||
{ name: "底图", description: "保留", kind: "background", generation: backgroundGeneration, extraction: { method: "source" } },
|
||
{ name: "完整场景", description: "照片", kind: "object", generation: objectGeneration, editUnit: "scene", bbox: [100, 100, 500, 700], extraction },
|
||
],
|
||
}),
|
||
);
|
||
const planned = applyImageLayerPlanningPurpose(raw, "materials");
|
||
expect(planned.layers[1].extraction).toEqual({ method: "source-region" });
|
||
expect(planned.warnings?.join(" ")).toContain("请框选完整边界");
|
||
}
|
||
});
|
||
test("重组目的存在移除项时不能原样复制底图，未知分类不冒充完整场景", () => {
|
||
const plan = parseImageLayerPlan(
|
||
JSON.stringify({
|
||
canPlan: true,
|
||
layers: [
|
||
{ name: "底图", description: "保留", kind: "background", generation: backgroundGeneration, extraction: { method: "source" } },
|
||
{ name: "复杂组合", description: "重叠轮廓", kind: "object", generation: objectGeneration, editUnit: "group", removeFromBackground: true, extraction: { method: "generate" } },
|
||
],
|
||
}),
|
||
);
|
||
const next = applyImageLayerPlanningPurpose(plan, "recompose");
|
||
expect(next.layers[0].extraction?.method).toBe("generate");
|
||
expect(next.layers[1].extraction?.method).toBe("generate");
|
||
expect(imageLayerTargetName("场景名称：内部描述，区域 <bbox>0 0 200 500</bbox>")).toBe("场景名称");
|
||
});
|
||
test("识图模型的 extraction 内坐标仍按显式单位校验，冲突坐标不得静默选择", () => {
|
||
const size = { width: 1000, height: 500 };
|
||
const layer = {
|
||
name: "场景",
|
||
description: "完整场景与内部背景",
|
||
kind: "object",
|
||
generation: objectGeneration,
|
||
editUnit: "scene",
|
||
removeFromBackground: false,
|
||
extraction: { method: "source-region", shape: "rounded-rect", radiusRatio: 0.04, bbox: [50, 100, 450, 400] },
|
||
};
|
||
const value = { canPlan: true, coordinateSpace: "pixels", imageSize: size, layers: [{ name: "底图", description: "保留原图", kind: "background", generation: backgroundGeneration, extraction: { method: "source" } }, layer] };
|
||
const plan = parseImageLayerPlan(JSON.stringify(value), size);
|
||
expect(plan.layers[1].extraction?.region?.bbox).toEqual([50, 200, 450, 800]);
|
||
expect(plan.layers[1].extraction?.region?.shape).toBe("rounded-rect");
|
||
expect(parseImageLayerPlan(JSON.stringify(value)).layers[1].extraction?.region).toBeUndefined();
|
||
expect(parseImageLayerPlan(JSON.stringify(value), { width: 500, height: 250 }).layers[1].extraction?.region).toBeUndefined();
|
||
const conflict = parseImageLayerPlan(JSON.stringify({ ...value, layers: [value.layers[0], { ...layer, bbox: [60, 100, 450, 400] }] }), size);
|
||
expect(conflict.layers[1].extraction?.region).toBeUndefined();
|
||
expect(conflict.warnings?.join(" ")).toContain("冲突");
|
||
expect(parseImageLayerPlan(JSON.stringify({ ...value, layers: [value.layers[0], { ...layer, bbox: layer.extraction.bbox }] }), size).layers[1].bbox).toEqual([50, 200, 450, 800]);
|
||
});
|
||
test("原图比例在持久化任务前转为协议像素尺寸，提取与去背景都满足后端尺寸校验", () => {
|
||
const profile = defaultModelCapabilityConfig("openai", "image-2.5-flare").image!;
|
||
profile.size = { ...profile.size, parameter: "size", values: ["auto"], allowCustom: true };
|
||
for (const source of [
|
||
{ width: 731, height: 412 },
|
||
{ width: 600, height: 900 },
|
||
]) {
|
||
const request = resolveImageRequestSize(profile, undefined, `${source.width}:${source.height}`)!;
|
||
expect(request.parameter).toBe("size");
|
||
expect(request.value).toMatch(/^\d+x\d+$/);
|
||
const [width, height] = request.value.split("x").map(Number);
|
||
expect(() => validateImageSize(width, height)).not.toThrow();
|
||
expect(Math.abs(width / height / (source.width / source.height) - 1)).toBeLessThan(0.01);
|
||
}
|
||
});
|
||
test("文本模型保持可选，只有选中的无识图能力模型报错，不猜模型名", () => {
|
||
expect(selectableModelsByCapability(config, "text")).toContain("models::visual");
|
||
expect(selectableModelsByCapability(config, "text")).toContain("models::blind");
|
||
expect(imageLayerPlannerError(config, "models::visual")).toBe("");
|
||
expect(imageLayerPlannerError(config, "models::blind")).toContain("未配置识图");
|
||
expect(imageLayerPlannerError(config, "models::editor")).toContain("文本模型");
|
||
expect(imageLayerPlannerError(config, "")).toContain("请选择");
|
||
});
|
||
test("普通拆层不局限 OpenAI 协议，必须是接受参考图的图片模型", () => {
|
||
expect(supportsExperimentalLayerExtraction(config, "models::editor")).toBe(true);
|
||
expect(supportsExperimentalLayerExtraction(config, "models::visual")).toBe(false);
|
||
const noReferences = { ...image, image: { ...image.image!, references: { ...image.image!.references, maxImages: 0 } } };
|
||
const altered = { ...config, channels: [{ ...channel, modelCosts: channel.modelCosts!.map((cost) => (cost.model === "editor" ? { ...cost, capabilityConfig: noReferences } : cost)) }] };
|
||
expect(supportsExperimentalLayerExtraction(altered, "models::editor")).toBe(false);
|
||
});
|
||
test("规划层数和题材来自模型真实结果，允许二层和多层", () => {
|
||
const plan = parseImageLayerPlan(JSON.stringify(response()));
|
||
expect(plan.layers.map((layer) => layer.name)).toEqual(["背景", "人物", "花束", "标题文字"]);
|
||
expect(imageLayerPlanTargets(plan)[1]).toContain("区域 <bbox>100 200 800 900</bbox>");
|
||
expect(parseImageLayerPlan("```json\n" + JSON.stringify(response(["背景", "产品"])) + "\n```").layers).toHaveLength(2);
|
||
});
|
||
test("未声明移除时保留原内容；模型显式选项必须是布尔值", () => {
|
||
const planned = response();
|
||
expect(parseImageLayerPlan(JSON.stringify(planned)).layers.map((layer) => layer.removeFromBackground)).toEqual([undefined, false, false, false]);
|
||
const details = { ...planned, layers: planned.layers.map((layer, i) => ({ ...layer, ...(i ? { removeFromBackground: i === 2 } : {}) })) };
|
||
expect(parseImageLayerPlan(JSON.stringify(details)).layers.map((layer) => layer.removeFromBackground)).toEqual([undefined, false, true, false]);
|
||
expect(() => parseImageLayerPlan(JSON.stringify({ ...details, layers: details.layers.map((layer) => ({ ...layer, removeFromBackground: "true" })) }))).toThrow("移除选项");
|
||
});
|
||
test("不能识图、空结果或非 JSON 不作为计划继续执行", () => {
|
||
expect(() => parseImageLayerPlan('{"canPlan":false,"reason":"无法读取图片"}')).toThrow("无法读取图片");
|
||
expect(() => parseImageLayerPlan("我建议分三层")).toThrow("JSON");
|
||
expect(() => parseImageLayerPlan(JSON.stringify(response(["只有一层"])))).toThrow("2–8");
|
||
expect(() => parseImageLayerPlan(JSON.stringify(response(Array.from({ length: 9 }, (_, index) => `层${index}`))))).toThrow("2–8");
|
||
});
|
||
test("拒绝无效语义，丢弃无效可选坐标而保留已识别图层", () => {
|
||
expect(() => parseImageLayerPlan(JSON.stringify(response(["背景", "重复", "重复"])))).toThrow("重复");
|
||
const wrong = response();
|
||
wrong.layers[1].kind = "background";
|
||
expect(() => parseImageLayerPlan(JSON.stringify(wrong))).toThrow("独立对象");
|
||
for (const bbox of [
|
||
[800, 200, 100, 900],
|
||
[0, 0, 1001, 900],
|
||
[0, 0, 1, 1],
|
||
]) {
|
||
const bad = response();
|
||
bad.layers[1].bbox = bbox;
|
||
const plan = parseImageLayerPlan(JSON.stringify(bad));
|
||
expect(plan.layers).toHaveLength(4);
|
||
expect(plan.layers[1]).not.toHaveProperty("bbox");
|
||
expect(plan.warnings?.[0]).toContain("坐标");
|
||
}
|
||
expect(parseImageLayerPlan(JSON.stringify({ ...response(), code: "ignored", model: "untrusted" }))).not.toHaveProperty("model");
|
||
});
|
||
test("四格海报部分旧坐标超过1000时，七层语义仍可用且不猜坐标单位", () => {
|
||
const names = ["底图背景", "主标题文字", "副标题文字", "左上照片", "右上照片", "左下照片", "右下照片"];
|
||
const value = response(names);
|
||
value.layers[1].bbox = [65, 30, 1010, 85];
|
||
value.layers[4].bbox = [547, 167, 1017, 547];
|
||
const plan = parseImageLayerPlan(JSON.stringify(value));
|
||
expect(plan.layers.map((layer) => layer.name)).toEqual(names);
|
||
expect(plan.warnings).toHaveLength(2);
|
||
expect(imageLayerPlanTargets(plan)[1]).not.toContain("bbox");
|
||
expect(plan.layers[2].bbox).toEqual([100, 200, 800, 900]);
|
||
});
|
||
test("显式单位与已知实际输入尺寸才转换像素坐标，保持归一化提示合同", () => {
|
||
const size = { width: 1600, height: 800 };
|
||
const value = response();
|
||
value.layers[1].bbox = [160, 160, 1280, 720];
|
||
const text = JSON.stringify({ ...value, coordinateSpace: "pixels", imageSize: size });
|
||
expect(parseImageLayerPlan(text, size).layers[1].bbox).toEqual([100, 200, 800, 900]);
|
||
expect(parseImageLayerPlan(text).layers[1]).not.toHaveProperty("bbox");
|
||
expect(parseImageLayerPlan(text, { width: 1000, height: 500 }).layers[1]).not.toHaveProperty("bbox");
|
||
value.layers[1].bbox = [0.1, 0.2, 0.8, 0.9];
|
||
expect(parseImageLayerPlan(JSON.stringify({ ...value, coordinateSpace: "relative" })).layers[1].bbox).toEqual([100, 200, 800, 900]);
|
||
expect(parseImageLayerPlan(JSON.stringify({ ...value, coordinateSpace: "unknown" })).layers[1]).not.toHaveProperty("bbox");
|
||
for (const bbox of [
|
||
[1, 2, 3],
|
||
[0, 0, "50", 60],
|
||
[null, 0, 1000, 1000],
|
||
]) {
|
||
expect(parseImageLayerPlan(JSON.stringify({ ...value, layers: value.layers.map((layer, index) => (index === 1 ? { ...layer, bbox } : layer)) })).layers[1]).not.toHaveProperty("bbox");
|
||
}
|
||
});
|
||
test("历史恢复跳过识图失败，只允许同画布同源图匹配资源", () => {
|
||
const task = (id: string, metadata: Record<string, unknown>, text: string, extra: Partial<GenerationTask> = {}): GenerationTask => ({
|
||
id,
|
||
projectId: "project",
|
||
type: "canvas_text",
|
||
status: "succeeded",
|
||
model: "vision",
|
||
createdAt: id,
|
||
updatedAt: id,
|
||
prompt: "plan",
|
||
attempts: 1,
|
||
inputJson: JSON.stringify({ metadata }),
|
||
resultJson: JSON.stringify({ text }),
|
||
...extra,
|
||
});
|
||
const metadata = { edit: "layer-planning", sourceNodeId: "source", sourceStorageKey: "image-key" };
|
||
const tasks = [
|
||
task("1", metadata, JSON.stringify(response())),
|
||
task("2", metadata, '{"canPlan":false,"reason":"无法读图"}'),
|
||
task("3", metadata, "broken"),
|
||
task("4", metadata, JSON.stringify(response()), { projectId: "other" }),
|
||
task("5", { ...metadata, sourceNodeId: "other" }, JSON.stringify(response())),
|
||
task("6", { ...metadata, sourceStorageKey: "replaced-key" }, JSON.stringify(response())),
|
||
task("7", metadata, JSON.stringify(response()), { type: "canvas_image" }),
|
||
task("8", metadata, JSON.stringify(response()), { status: "running" }),
|
||
];
|
||
expect(latestImageLayerPlan(tasks, "project", "source", "image-key")?.taskId).toBe("1");
|
||
expect(latestImageLayerPlan(tasks, "none", "source", "image-key")).toBeUndefined();
|
||
const legacy = latestImageLayerPlan([task("1", { edit: "layer-planning", sourceNodeId: "source" }, JSON.stringify(response()))], "project", "source", "image-key");
|
||
expect(legacy?.warnings?.join(" ")).toContain("旧记录");
|
||
});
|
||
test("海报整张照片内部场景保留，坐标可省略且以实际参考图为准", () => {
|
||
const prompt = imageLayerPlanningPrompt("自动拆分", { width: 1000, height: 1000 });
|
||
expect(prompt).toContain("完整 scene 禁止重画或内部去背景");
|
||
expect(prompt).toContain('coordinateSpace="pixels"');
|
||
expect(prompt).toContain("1000×1000");
|
||
});
|
||
test("输出比例优先匹配源图配置合同，不把任意原像素尺寸发送给模型", () => {
|
||
const profile = { ...image, image: { ...image.image!, size: { parameter: "size" as const, values: ["1:1", "16:9", "auto"], default: "1:1", allowCustom: false } } };
|
||
const outputConfig = { ...config, channels: [{ ...channel, modelCosts: channel.modelCosts!.map((cost) => (cost.model === "editor" ? { ...cost, capabilityConfig: profile } : cost)) }] };
|
||
expect(imageLayerOutputSize(outputConfig, "models::editor", { width: 731, height: 412 })).toBe("16:9");
|
||
expect(imageLayerOutputSize(outputConfig, "models::editor", { width: 997, height: 700 })).toBe("auto");
|
||
const fixed = {
|
||
...outputConfig,
|
||
channels: [
|
||
{ ...outputConfig.channels[0], modelCosts: outputConfig.channels[0].modelCosts!.map((cost) => ({ ...cost, capabilityConfig: { ...profile, image: { ...profile.image, size: { ...profile.image.size, values: ["1:1", "16:9"] } } } })) },
|
||
],
|
||
};
|
||
expect(imageLayerOutputSize(fixed, "models::editor", { width: 997, height: 700 })).toBe("");
|
||
expect(imageLayerOutputSize(outputConfig, "models::editor")).toBe("");
|
||
const custom = {
|
||
...outputConfig,
|
||
channels: [{ ...outputConfig.channels[0], modelCosts: outputConfig.channels[0].modelCosts!.map((cost) => ({ ...cost, capabilityConfig: { ...profile, image: { ...profile.image, size: { ...profile.image.size, allowCustom: true } } } })) }],
|
||
};
|
||
expect(imageLayerOutputSize(custom, "models::editor", { width: 731, height: 412 })).toBe("731:412");
|
||
expect(imageLayerOutputSize(custom, "models::editor", { width: 600, height: 900 })).toBe("600:900");
|
||
expect(imageLayerOutputSize(custom, "models::editor", { width: 0, height: 900 })).toBe("");
|
||
});
|
||
});
|