Preparing v0.24.0

src/modules/extras/ModuleDev.ts

@@ -0,0 +1,111 @@
+import { fireAndForget } from "octagonal-wheels/promises";
+import { __onMissingTranslation } from "../../lib/src/common/i18n";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { eventHub } from "../../common/events";
+import { enableTestFunction } from "./devUtil/testUtils.ts";
+import { TestPaneView, VIEW_TYPE_TEST } from "./devUtil/TestPaneView.ts";
+import { writable } from "svelte/store";
+
+export class ModuleDev extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadAfterLoadSettings(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        __onMissingTranslation(() => { });
+        // eslint-disable-next-line no-unused-labels
+        __onMissingTranslation((key) => {
+            const now = new Date();
+            const filename = `missing-translation-`
+            const time = now.toISOString().split("T")[0];
+            const outFile = `${filename}${time}.jsonl`;
+            const piece = JSON.stringify(
+                {
+                    [key]: {}
+                }
+            )
+            const writePiece = piece.substring(1, piece.length - 1) + ",";
+            fireAndForget(async () => {
+                try {
+                    await this.core.storageAccess.ensureDir(this.app.vault.configDir + "/ls-debug/");
+                    await this.core.storageAccess.appendHiddenFile(this.app.vault.configDir + "/ls-debug/" + outFile, writePiece + "\n")
+                } catch (ex) {
+                    this._log(`Could not write ${outFile}`, LOG_LEVEL_VERBOSE);
+                    this._log(`Missing translation: ${writePiece}`, LOG_LEVEL_VERBOSE);
+                    this._log(ex, LOG_LEVEL_VERBOSE);
+                }
+            });
+        })
+        type STUB = {
+            toc: Set<string>,
+            stub: { [key: string]: { [key: string]: Map<string, Record<string, string>> } }
+        };
+        eventHub.onEvent("document-stub-created", (e: CustomEvent<STUB>) => {
+            fireAndForget(async () => {
+                const stub = e.detail.stub;
+                const toc = e.detail.toc;
+
+                const stubDocX =
+                    Object.entries(stub).map(([key, value]) => {
+                        return [`## ${key}`, Object.entries(value).
+                            map(([key2, value2]) => {
+                                return [`### ${key2}`,
+                                ([...(value2.entries())].map(([key3, value3]) => {
+                                    // return `#### ${key3}` + "\n" + JSON.stringify(value3);
+                                    const isObsolete = value3["is_obsolete"] ? " (obsolete)" : "";
+                                    const desc = value3["desc"] ?? "";
+                                    const key = value3["key"] ? "Setting key: " + value3["key"] + "\n" : "";
+                                    return `#### ${key3}${isObsolete}\n${key}${desc}\n`
+                                }))].flat()
+                            }).flat()].flat()
+                    }).flat();
+                const stubDocMD = `
+| Icon  | Description                                                       |
+| :---: | ----------------------------------------------------------------- |
+` +
+                    [...toc.values()].map(e => `${e}`).join("\n") + "\n\n" +
+                    stubDocX.join("\n");
+                await this.core.storageAccess.writeHiddenFileAuto(this.app.vault.configDir + "/ls-debug/stub-doc.md", stubDocMD);
+            })
+        });
+
+        enableTestFunction(this.plugin);
+        this.registerView(
+            VIEW_TYPE_TEST,
+            (leaf) => new TestPaneView(leaf, this.plugin, this)
+        );
+        this.addCommand({
+            id: "view-test",
+            name: "Open Test dialogue",
+            callback: () => {
+                void this.core.$$showView(VIEW_TYPE_TEST);
+            }
+        });
+        return Promise.resolve(true);
+    }
+    async $everyOnLayoutReady(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        if (await this.core.storageAccess.isExistsIncludeHidden("_SHOWDIALOGAUTO.md")) {
+            void this.core.$$showView(VIEW_TYPE_TEST);
+        }
+        return true;
+    }
+    testResults = writable<[boolean, string, string][]>([]);
+    // testResults: string[] = [];
+
+    $$addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void {
+        const logLine = `${name}: ${key} ${summary ?? ""}`;
+        this.testResults.update((results) => {
+            results.push([result, logLine, message ?? ""]);
+            return results;
+        });
+    }
+    $everyModuleTest(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        // this.core.$$addTestResult("DevModule", "Test", true);
+        // return Promise.resolve(true);
+        // this.addTestResult("Test of test1", true, "Just OK", "This is a test of test");
+        // this.addTestResult("Test of test2", true, "Just OK?");
+        // this.addTestResult("Test of test3", true);
+        return this.testDone();
+    }
+}

src/modules/extras/ModuleIntegratedTest.ts

@@ -0,0 +1,441 @@
+import { delay } from "octagonal-wheels/promises";
+import { LOG_LEVEL_NOTICE, REMOTE_MINIO, type FilePathWithPrefix } from "src/lib/src/common/types";
+import { shareRunningResult } from "octagonal-wheels/concurrency/lock";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule";
+
+export class ModuleIntegratedTest extends AbstractObsidianModule implements IObsidianModule {
+
+    async waitFor(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
+        await delay(100);
+        const start = Date.now();
+        while (!await proc()) {
+            if (timeout > 0) {
+                if (Date.now() - start > timeout) {
+                    this._log(`Timeout`);
+                    return false;
+                }
+            }
+            await delay(500);
+        }
+        return true;
+    }
+    waitWithReplicating(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
+        return this.waitFor(async () => {
+            await this.tryReplicate();
+            return await proc();
+        }, timeout);
+    }
+    async storageContentIsEqual(file: string, content: string): Promise<boolean> {
+        try {
+            const fileContent = await this.readStorageContent(file as FilePathWithPrefix);
+            if (fileContent === content) {
+                return true;
+            } else {
+                // this._log(`Content is not same \n Expected:${content}\n Actual:${fileContent}`, LOG_LEVEL_VERBOSE);
+                return false;
+            }
+        } catch (e) {
+            this._log(`Error: ${e}`);
+            return false;
+        }
+    }
+    async assert(proc: () => Promise<boolean>): Promise<boolean> {
+        if (!await proc()) {
+            this._log(`Assertion failed`);
+            return false;
+        }
+        return true;
+    }
+    async _orDie(key: string, proc: () => Promise<boolean>): Promise<true> | never {
+        if (!await this._test(key, proc)) {
+            throw new Error(`${key}`);
+        }
+        return true;
+    }
+    tryReplicate() {
+        if (!this.settings.liveSync) {
+            return shareRunningResult("replicate-test", async () => { await this.core.$$replicate() });
+        }
+    }
+    async readStorageContent(file: FilePathWithPrefix): Promise<string | undefined> {
+        if (!await this.core.storageAccess.isExistsIncludeHidden(file)) {
+            return undefined;
+        }
+        return await this.core.storageAccess.readHiddenFileText(file);
+    }
+    async _proceed(no: number, title: string): Promise<boolean> {
+        const stepFile = "_STEP.md" as FilePathWithPrefix;
+        const stepAckFile = "_STEP_ACK.md" as FilePathWithPrefix;
+        const stepContent = `Step ${no}`;
+        await this.core.$anyResolveConflictByNewest(stepFile);
+        await this.core.storageAccess.writeFileAuto(stepFile, stepContent);
+        await this._orDie(`Wait for acknowledge ${no}`, async () => {
+            if (!await this.waitWithReplicating(
+                async () => {
+                    return await this.storageContentIsEqual(stepAckFile, stepContent)
+                }, 20000)
+            ) return false;
+            return true;
+        })
+        return true;
+    }
+    async _join(no: number, title: string): Promise<boolean> {
+        const stepFile = "_STEP.md" as FilePathWithPrefix;
+        const stepAckFile = "_STEP_ACK.md" as FilePathWithPrefix;
+        // const otherStepFile = `_STEP_${isLeader ? "R" : "L"}.md` as FilePathWithPrefix;
+        const stepContent = `Step ${no}`;
+
+        await this._orDie(`Wait for step ${no} (${title})`, async () => {
+            if (!await this.waitWithReplicating(
+                async () => {
+                    return await this.storageContentIsEqual(stepFile, stepContent)
+                }, 20000)
+            ) return false;
+            return true;
+        }
+        )
+        await this.core.$anyResolveConflictByNewest(stepAckFile);
+        await this.core.storageAccess.writeFileAuto(stepAckFile, stepContent);
+        await this.tryReplicate();
+        return true;
+    }
+
+    async performStep({
+        step,
+        title,
+        isGameChanger,
+        proc,
+        check
+    }: {
+        step: number,
+        title: string,
+        isGameChanger: boolean,
+        proc: () => Promise<any>,
+        check: () => Promise<boolean>,
+    }): Promise<boolean> {
+        if (isGameChanger) {
+            await this._proceed(step, title);
+            try {
+                await proc();
+            } catch (e) {
+                this._log(`Error: ${e}`);
+                return false;
+            }
+            return await this._orDie(`Step ${step} - ${title}`,
+                async () => await this.waitWithReplicating(check)
+            );
+        } else {
+            return await this._join(step, title);
+        }
+    }
+    // // see scenario.md
+    // async testLeader(testMain: (testFileName: FilePathWithPrefix) => Promise<boolean>): Promise<boolean> {
+
+    // }
+    // async testReceiver(testMain: (testFileName: FilePathWithPrefix) => Promise<boolean>): Promise<boolean> {
+
+    // }
+    async nonLiveTestRunner(isLeader: boolean, testMain: (testFileName: FilePathWithPrefix, isLeader: boolean) => Promise<boolean>): Promise<boolean> {
+        const storage = this.core.storageAccess;
+        // const database = this.core.databaseFileAccess;
+        // const _orDie = this._orDie.bind(this);
+        const testCommandFile = "IT.md" as FilePathWithPrefix;
+        const textCommandResponseFile = "ITx.md" as FilePathWithPrefix;
+        let testFileName: FilePathWithPrefix;
+        this.addTestResult("-------Starting ... ", true, `Test as ${isLeader ? "Leader" : "Receiver"} command file ${testCommandFile}`);
+        if (isLeader) {
+            await this._proceed(0, "start");
+        }
+        await this.tryReplicate();
+
+        await this.performStep({
+            step: 0,
+            title: "Make sure that command File Not Exists",
+            isGameChanger: isLeader,
+            proc: async () => await storage.removeHidden(testCommandFile),
+            check: async () => !(await storage.isExistsIncludeHidden(testCommandFile)),
+        })
+        await this.performStep({
+            step: 1,
+            title: "Make sure that command File Not Exists On Receiver",
+            isGameChanger: !isLeader,
+            proc: async () => await storage.removeHidden(textCommandResponseFile),
+            check: async () => !(await storage.isExistsIncludeHidden(textCommandResponseFile)),
+        })
+
+        await this.performStep({
+            step: 2,
+            title: "Decide the test file name",
+            isGameChanger: isLeader,
+            proc: async () => {
+                testFileName = (Date.now() + "-" + Math.ceil(Math.random() * 1000) + ".md") as FilePathWithPrefix;
+                const testCommandFile = "IT.md" as FilePathWithPrefix;
+                await storage.writeFileAuto(testCommandFile, testFileName);
+            },
+            check: () => Promise.resolve(true),
+        })
+        await this.performStep({
+            step: 3,
+            title: "Wait for the command file to be arrived",
+            isGameChanger: !isLeader,
+            proc: async () => { },
+            check: async () => await storage.isExistsIncludeHidden(testCommandFile),
+        })
+
+        await this.performStep({
+            step: 4,
+            title: "Send the response file",
+            isGameChanger: !isLeader,
+            proc: async () => {
+                await storage.writeHiddenFileAuto(textCommandResponseFile, "!");
+            },
+            check: () => Promise.resolve(true),
+        })
+        await this.performStep({
+            step: 5,
+            title: "Wait for the response file to be arrived",
+            isGameChanger: isLeader,
+            proc: async () => { },
+            check: async () => await storage.isExistsIncludeHidden(textCommandResponseFile),
+        })
+
+        await this.performStep({
+            step: 6,
+            title: "Proceed to begin the test",
+            isGameChanger: isLeader,
+            proc: async () => {
+
+            },
+            check: () => Promise.resolve(true),
+        });
+        await this.performStep({
+            step: 6,
+            title: "Begin the test",
+            isGameChanger: !false,
+            proc: async () => {
+            },
+            check: () => {
+                return Promise.resolve(true);
+            },
+        })
+        // await this.step(0, isLeader, true);
+        try {
+            this.addTestResult("** Main------", true, ``);
+            if (isLeader) {
+                return await testMain(testFileName!, true);
+            } else {
+                const testFileName = await this.readStorageContent(testCommandFile);
+                this.addTestResult("testFileName", true, `Request client to use :${testFileName!}`);
+                return await testMain(testFileName! as FilePathWithPrefix, false);
+            }
+        } finally {
+            this.addTestResult("Teardown", true, `Deleting ${testFileName!}`);
+            await storage.removeHidden(testFileName!);
+        }
+
+        return true;
+        // Make sure the 
+    }
+
+
+    async testBasic(filename: FilePathWithPrefix, isLeader: boolean): Promise<boolean> {
+        const storage = this.core.storageAccess;
+        const database = this.core.databaseFileAccess;
+
+        await this.addTestResult(`---**Starting Basic Test**---`, true, `Test as ${isLeader ? "Leader" : "Receiver"} command file ${filename}`);
+        // if (isLeader) {
+        //     await this._proceed(0);
+        // }
+        // await this.tryReplicate();
+
+        await this.performStep({
+            step: 0,
+            title: "Make sure that file is not exist",
+            isGameChanger: !isLeader,
+            proc: async () => { },
+            check: async () => !(await storage.isExists(filename)),
+        })
+
+
+        await this.performStep({
+            step: 1,
+            title: "Write a file",
+            isGameChanger: isLeader,
+            proc: async () => await storage.writeFileAuto(filename, "Hello World"),
+            check: async () => await storage.isExists(filename),
+        })
+        await this.performStep({
+            step: 2,
+            title: "Make sure the file is arrived",
+            isGameChanger: !isLeader,
+            proc: async () => { },
+            check: async () => await storage.isExists(filename),
+        })
+        await this.performStep({
+            step: 3,
+            title: "Update to Hello World 2",
+            isGameChanger: isLeader,
+            proc: async () => await storage.writeFileAuto(filename, "Hello World 2"),
+            check: async () => await this.storageContentIsEqual(filename, "Hello World 2"),
+        })
+        await this.performStep({
+            step: 4,
+            title: "Make sure the modified file is arrived",
+            isGameChanger: !isLeader,
+            proc: async () => { },
+            check: async () => await this.storageContentIsEqual(filename, "Hello World 2"),
+        })
+        await this.performStep({
+            step: 5,
+            title: "Update to Hello World 3",
+            isGameChanger: !isLeader,
+            proc: async () => await storage.writeFileAuto(filename, "Hello World 3"),
+            check: async () => await this.storageContentIsEqual(filename, "Hello World 3"),
+        })
+        await this.performStep({
+            step: 6,
+            title: "Make sure the modified file is arrived",
+            isGameChanger: isLeader,
+            proc: async () => { },
+            check: async () => await this.storageContentIsEqual(filename, "Hello World 3"),
+        })
+
+        const multiLineContent = `Line1:A
+Line2:B
+Line3:C
+Line4:D`
+
+        await this.performStep({
+            step: 7,
+            title: "Update to Multiline",
+            isGameChanger: isLeader,
+            proc: async () => await storage.writeFileAuto(filename, multiLineContent),
+            check: async () => await this.storageContentIsEqual(filename, multiLineContent),
+        })
+
+        await this.performStep({
+            step: 8,
+            title: "Make sure the modified file is arrived",
+            isGameChanger: !isLeader,
+            proc: async () => { },
+            check: async () => await this.storageContentIsEqual(filename, multiLineContent),
+        })
+
+        // While LiveSync, possibly cannot cause the conflict.
+        if (!this.settings.liveSync) {
+
+
+
+            // Step 9 Make Conflict But Resolvable
+            const multiLineContentL = `Line1:A
+Line2:B
+Line3:C!
+Line4:D`
+            const multiLineContentC = `Line1:A
+Line2:bbbbb
+Line3:C
+Line4:D`
+
+            await this.performStep({
+                step: 9,
+                title: "Progress to be conflicted",
+                isGameChanger: isLeader,
+                proc: async () => { },
+                check: () => Promise.resolve(true),
+            })
+
+            await storage.writeFileAuto(filename, isLeader ? multiLineContentL : multiLineContentC);
+
+            await this.performStep({
+                step: 10,
+                title: "Update As Conflicted",
+                isGameChanger: !isLeader,
+                proc: async () => { },
+                check: () => Promise.resolve(true),
+            })
+
+            await this.performStep({
+                step: 10,
+                title: "Make sure Automatically resolved",
+                isGameChanger: isLeader,
+                proc: async () => { },
+                check: async () => (await database.getConflictedRevs(filename)).length === 0,
+            })
+            await this.performStep({
+                step: 11,
+                title: "Make sure Automatically resolved",
+                isGameChanger: !isLeader,
+                proc: async () => { },
+                check: async () => (await database.getConflictedRevs(filename)).length === 0,
+            })
+
+
+
+            const sensiblyMergedContent = `Line1:A
+Line2:bbbbb
+Line3:C!
+Line4:D`
+
+            await this.performStep({
+                step: 12,
+                title: "Make sure Sensibly Merged on Leader",
+                isGameChanger: isLeader,
+                proc: async () => { },
+                check: async () => await this.storageContentIsEqual(filename, sensiblyMergedContent),
+            })
+            await this.performStep({
+                step: 13,
+                title: "Make sure Sensibly Merged on Receiver",
+                isGameChanger: !isLeader,
+                proc: async () => { },
+                check: async () => await this.storageContentIsEqual(filename, sensiblyMergedContent),
+            })
+        }
+        await this.performStep({
+            step: 14,
+            title: "Delete File",
+            isGameChanger: isLeader,
+            proc: async () => { await storage.removeHidden(filename) },
+            check: async () => !await storage.isExists(filename),
+        })
+
+        await this.performStep({
+            step: 15,
+            title: "Make sure File is deleted",
+            isGameChanger: !isLeader,
+            proc: async () => { },
+            check: async () => !await storage.isExists(filename),
+        })
+        this._log(`The Basic Test has been completed`, LOG_LEVEL_NOTICE);
+        return true;
+    }
+
+    async testBasicEvent(isLeader: boolean) {
+        this.settings.liveSync = false;
+        await this.saveSettings();
+        await this._test("basic", async () => await this.nonLiveTestRunner(isLeader, (t, l) => this.testBasic(t, l)));
+    }
+    async testBasicLive(isLeader: boolean) {
+        this.settings.liveSync = true;
+        await this.saveSettings();
+        await this._test("basic", async () => await this.nonLiveTestRunner(isLeader, (t, l) => this.testBasic(t, l)));
+    }
+
+    async $everyModuleTestMultiDevice(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        const isLeader = this.core.$$vaultName().indexOf("recv") === -1;
+        this.addTestResult("-------", true, `Test as ${isLeader ? "Leader" : "Receiver"}`);
+        try {
+            this._log(`Starting Test`);
+            await this.testBasicEvent(isLeader);
+            if (this.settings.remoteType == REMOTE_MINIO) await this.testBasicLive(isLeader);
+
+        } catch (e) {
+            this._log(e)
+            this._log(`Error: ${e}`);
+            return Promise.resolve(false);
+        }
+
+        return Promise.resolve(true);
+    }
+}

src/modules/extras/ModuleReplicateTest.ts

@@ -0,0 +1,528 @@
+import { delay } from "octagonal-wheels/promises";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { eventHub } from "../../common/events";
+import { webcrypto } from "crypto";
+import { uint8ArrayToHexString } from "octagonal-wheels/binary/hex";
+import { parseYaml, requestUrl, stringifyYaml } from "obsidian";
+import type { FilePath } from "../../lib/src/common/types.ts";
+import { scheduleTask } from "octagonal-wheels/concurrency/task";
+
+export class ModuleReplicateTest extends AbstractObsidianModule implements IObsidianModule {
+
+
+    testRootPath = "_test/";
+    testInfoPath = "_testinfo/";
+
+    get isLeader() {
+        return this.core.$$getVaultName().indexOf("dev") >= 0 && this.core.$$vaultName().indexOf("recv") < 0;
+    }
+
+
+    get nameByKind() {
+        if (!this.isLeader) {
+            return "RECV";
+        } else if (this.isLeader) {
+            return "LEADER";
+        }
+    }
+    get pairName() {
+        if (this.isLeader) {
+            return "RECV";
+        } else if (!this.isLeader) {
+            return "LEADER";
+        }
+    }
+
+    watchIsSynchronised = false;
+
+    statusBarSyncStatus?: HTMLElement;
+    async readFileContent(file: string) {
+        try {
+            return await this.core.storageAccess.readHiddenFileText(file);
+        } catch {
+            return "";
+        }
+    }
+
+
+    async dumpList() {
+        if (this.settings.syncInternalFiles) {
+            this._log("Write file list (Include Hidden)");
+            await this._dumpFileListIncludeHidden("files.md");
+        } else {
+            this._log("Write file list");
+            await this._dumpFileList("files.md");
+        }
+    }
+    async $everyBeforeReplicate(showMessage: boolean): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        await this.dumpList();
+        return true;
+    }
+    $everyOnloadAfterLoadSettings(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        this.addCommand({
+            id: "dump-file-structure-normal",
+            name: `Dump Structure (Normal)`,
+            callback: () => {
+                void this._dumpFileList("files.md").finally(() => {
+                    void this.refreshSyncStatus();
+                });
+
+            }
+        })
+        this.addCommand({
+            id: "dump-file-structure-ih",
+            name: "Dump Structure (Include Hidden)",
+            callback: () => {
+                const d = "files.md";
+                void this._dumpFileListIncludeHidden(d);
+            }
+        })
+        this.addCommand({
+            id: "dump-file-structure-auto",
+            name: "Dump Structure",
+            callback: () => {
+                void this.dumpList();
+            }
+        })
+        this.addCommand({
+            id: "dump-file-test",
+            name: `Perform Test (Dev) ${this.isLeader ? "(Leader)" : "(Recv)"}`,
+            callback: () => {
+                void this.performTestManually();
+            }
+        })
+        this.addCommand({
+            id: "watch-sync-result",
+            name: `Watch sync result is matched between devices`,
+            callback: () => {
+                this.watchIsSynchronised = !this.watchIsSynchronised;
+                void this.refreshSyncStatus();
+            }
+        })
+        this.app.vault.on("modify", async (file) => {
+            if (file.path.startsWith(this.testInfoPath)) {
+                await this.refreshSyncStatus();
+            } else {
+                scheduleTask("dumpStatus", 125, async () => {
+                    await this.dumpList();
+                    return true;
+                });
+            }
+        })
+        this.statusBarSyncStatus = this.plugin.addStatusBarItem();
+        return Promise.resolve(true);
+    }
+    async getSyncStatusAsText() {
+        const fileMine = this.testInfoPath + this.nameByKind + "/" + "files.md";
+        const filePair = this.testInfoPath + this.pairName + "/" + "files.md";
+        const mine = parseYaml(await this.readFileContent(fileMine));
+        const pair = parseYaml(await this.readFileContent(filePair));
+        const result = [] as string[];
+        if (mine.length != pair.length) {
+            result.push(`File count is different: ${mine.length} vs ${pair.length}`);
+        }
+        const filesAll = new Set([...mine.map((e: any) => e.path), ...pair.map((e: any) => e.path)]);
+        for (const file of filesAll) {
+            const mineFile = mine.find((e: any) => e.path == file);
+            const pairFile = pair.find((e: any) => e.path == file);
+            if (!mineFile || !pairFile) {
+                result.push(`File not found: ${file}`);
+            } else {
+                if (mineFile.size != pairFile.size) {
+                    result.push(`Size is different: ${file} ${mineFile.size} vs ${pairFile.size}`);
+                }
+                if (mineFile.hash != pairFile.hash) {
+                    result.push(`Hash is different: ${file} ${mineFile.hash} vs ${pairFile.hash}`);
+                }
+            }
+        }
+        eventHub.emitEvent("debug-sync-status", result);
+        return result.join("\n");
+    }
+
+    async refreshSyncStatus() {
+        if (this.watchIsSynchronised) {
+            // Normal Files
+            const syncStatus = await this.getSyncStatusAsText();
+            if (syncStatus) {
+                this.statusBarSyncStatus!.setText(`Sync Status: Having Error`);
+                this._log(`Sync Status: Having Error\n${syncStatus}`, LOG_LEVEL_INFO);
+            } else {
+                this.statusBarSyncStatus!.setText(`Sync Status: Synchronised`);
+            }
+        } else {
+            this.statusBarSyncStatus!.setText("");
+        }
+    }
+
+
+    async _dumpFileList(outFile?: string) {
+        const files = this.core.storageAccess.getFiles();
+        const out = [] as any[];
+        for (const file of files) {
+            if (!await this.core.$$isTargetFile(file.path)) {
+                continue;
+            }
+            if (file.path.startsWith(this.testInfoPath)) continue;
+            const stat = await this.core.storageAccess.stat(file.path);
+            if (stat) {
+                const hashSrc = await this.core.storageAccess.readHiddenFileBinary(file.path);
+                const hash = await webcrypto.subtle.digest("SHA-1", hashSrc);
+                const hashStr = uint8ArrayToHexString(new Uint8Array(hash));
+                const item = {
+                    path: file.path,
+                    name: file.name,
+                    size: stat.size,
+                    mtime: stat.mtime,
+                    hash: hashStr
+                }
+                // const fileLine = `-${file.path}:${stat.size}:${stat.mtime}:${hashStr}`;
+                out.push(item);
+            }
+        }
+        out.sort((a, b) => a.path.localeCompare(b.path));
+        if (outFile) {
+            outFile = this.testInfoPath + this.nameByKind + "/" + outFile;
+            await this.core.storageAccess.ensureDir(outFile);
+            await this.core.storageAccess.writeHiddenFileAuto(outFile, stringifyYaml(out));
+        } else {
+            // console.dir(out);
+        }
+        this._log(`Dumped ${out.length} files`, LOG_LEVEL_INFO);
+    }
+
+    async _dumpFileListIncludeHidden(outFile?: string) {
+        const ignorePatterns = this.settings.syncInternalFilesIgnorePatterns
+            .replace(/\n| /g, "")
+            .split(",").filter(e => e).map(e => new RegExp(e, "i"));
+        const out = [] as any[];
+        const files = await this.core.storageAccess.getFilesIncludeHidden("", undefined, ignorePatterns);
+        console.dir(files);
+        for (const file of files) {
+            // if (!await this.core.$$isTargetFile(file)) {
+            //     continue;
+            // }
+            if (file.startsWith(this.testInfoPath)) continue;
+            const stat = await this.core.storageAccess.statHidden(file);
+            if (stat) {
+                const hashSrc = await this.core.storageAccess.readHiddenFileBinary(file);
+                const hash = await webcrypto.subtle.digest("SHA-1", hashSrc);
+                const hashStr = uint8ArrayToHexString(new Uint8Array(hash));
+                const item = {
+                    path: file,
+                    name: file.split("/").pop(),
+                    size: stat.size,
+                    mtime: stat.mtime,
+                    hash: hashStr
+                }
+                // const fileLine = `-${file.path}:${stat.size}:${stat.mtime}:${hashStr}`;
+                out.push(item);
+            }
+        }
+        out.sort((a, b) => a.path.localeCompare(b.path));
+        if (outFile) {
+            outFile = this.testInfoPath + this.nameByKind + "/" + outFile;
+            await this.core.storageAccess.ensureDir(outFile);
+            await this.core.storageAccess.writeHiddenFileAuto(outFile, stringifyYaml(out));
+        } else {
+            // console.dir(out);
+        }
+        this._log(`Dumped ${out.length} files`, LOG_LEVEL_NOTICE);
+    }
+
+    async collectTestFiles() {
+        const remoteTopDir = "https://raw.githubusercontent.com/vrtmrz/obsidian-livesync/refs/heads/main/";
+        const files = [
+            "README.md",
+            "docs/adding_translations.md",
+            "docs/design_docs_of_journalsync.md",
+            "docs/design_docs_of_keep_newborn_chunks.md",
+            "docs/design_docs_of_prefixed_hidden_file_sync.md",
+            "docs/design_docs_of_sharing_tweak_value.md",
+            "docs/quick_setup_cn.md",
+            "docs/quick_setup_ja.md",
+            "docs/quick_setup.md",
+            "docs/settings_ja.md",
+            "docs/settings.md",
+            "docs/setup_cloudant_ja.md",
+            "docs/setup_cloudant.md",
+            "docs/setup_flyio.md",
+            "docs/setup_own_server_cn.md",
+            "docs/setup_own_server_ja.md",
+            "docs/setup_own_server.md",
+            "docs/tech_info_ja.md",
+            "docs/tech_info.md",
+            "docs/terms.md",
+            "docs/troubleshooting.md",
+            'images/1.png',
+            'images/2.png',
+            'images/corrupted_data.png',
+            'images/hatch.png',
+            'images/lock_pattern1.png',
+            'images/lock_pattern2.png',
+            'images/quick_setup_1.png',
+            'images/quick_setup_2.png',
+            'images/quick_setup_3.png',
+            'images/quick_setup_3b.png',
+            'images/quick_setup_4.png',
+            'images/quick_setup_5.png',
+            'images/quick_setup_6.png',
+            'images/quick_setup_7.png',
+            'images/quick_setup_8.png',
+            'images/quick_setup_9_1.png',
+            'images/quick_setup_9_2.png',
+            'images/quick_setup_10.png',
+            'images/remote_db_setting.png',
+            'images/write_logs_into_the_file.png',
+        ]
+        for (const file of files) {
+            const remote = remoteTopDir + file;
+            const local = this.testRootPath + file;
+            try {
+                const f = (await requestUrl(remote)).arrayBuffer;
+                await this.core.storageAccess.ensureDir(local);
+                await this.core.storageAccess.writeHiddenFileAuto(local, f);
+            } catch (ex) {
+                this._log(`Could not fetch ${remote}`, LOG_LEVEL_VERBOSE);
+                this._log(ex, LOG_LEVEL_VERBOSE);
+            }
+        }
+
+        await this.dumpList();
+    }
+
+    async waitFor(proc: () => Promise<boolean>, timeout = 10000): Promise<boolean> {
+        await delay(100);
+        const start = Date.now();
+        while (!await proc()) {
+            if (timeout > 0) {
+                if (Date.now() - start > timeout) {
+                    this._log(`Timeout`);
+                    return false;
+                }
+            }
+            await delay(500);
+        }
+        return true;
+    }
+
+    async testConflictedManually1() {
+
+        await this.core.$$replicate();
+
+        const commonFile = `Resolve! 
+*****, the amazing chocolatier!!`;
+
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", commonFile);
+        }
+
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+        if (await this.core.confirm.askYesNoDialog("Ready to begin the test conflict Manually 1?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+
+
+        const fileA = `Resolve to KEEP THIS
+Willy Wonka, Willy Wonka, the amazing chocolatier!!`
+
+        const fileB = `Resolve to DISCARD THIS
+Charlie Bucket, Charlie Bucket, the amazing chocolatier!!`
+
+
+
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", fileA);
+        } else {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "wonka.md", fileB);
+        }
+
+        if (await this.core.confirm.askYesNoDialog("Ready to check the result of Manually 1?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+
+
+        if (!await this.waitFor(async () => {
+            await this.core.$$replicate();
+            return await this.__assertStorageContent(this.testRootPath + "wonka.md" as FilePath, fileA, false, true) == true;
+        }, 30000)) {
+            return await this.__assertStorageContent(this.testRootPath + "wonka.md" as FilePath, fileA, false, true);
+        }
+        return true;
+        // We have to check the result
+    }
+
+    async testConflictedManually2() {
+
+        await this.core.$$replicate();
+
+        const commonFile = `Resolve To concatenate
+ABCDEFG`;
+
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", commonFile);
+        }
+
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+        if (await this.core.confirm.askYesNoDialog("Ready to begin the test conflict Manually 2?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+
+        const fileA = `Resolve to Concatenate
+ABCDEFGHIJKLMNOPQRSTYZ`
+
+        const fileB = `Resolve to Concatenate
+AJKLMNOPQRSTUVWXYZ`
+
+        const concatenated = `Resolve to Concatenate
+ABCDEFGHIJKLMNOPQRSTUVWXYZ`
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", fileA);
+        } else {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "concat.md", fileB);
+        }
+        if (await this.core.confirm.askYesNoDialog("Ready to test conflict Manually 2?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+
+
+        if (!await this.waitFor(async () => {
+            await this.core.$$replicate();
+            return await this.__assertStorageContent(this.testRootPath + "concat.md" as FilePath, concatenated, false, true) == true;
+        }, 30000)) {
+            return await this.__assertStorageContent(this.testRootPath + "concat.md" as FilePath, concatenated, false, true);
+        }
+        return true;
+
+    }
+
+    async testConflictAutomatic() {
+
+        if (this.isLeader) {
+            const baseDoc = `Tasks!
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+- [ ] Task 4
+`
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", baseDoc);
+        }
+        await delay(100)
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+
+        if (await this.core.confirm.askYesNoDialog("Ready to test conflict?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+        const mod1Doc = `Tasks!
+- [ ] Task 1
+- [v] Task 2
+- [ ] Task 3
+- [ ] Task 4
+`
+
+        const mod2Doc = `Tasks!
+- [ ] Task 1
+- [ ] Task 2
+- [v] Task 3
+- [ ] Task 4
+`
+        if (this.isLeader) {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", mod1Doc);
+        } else {
+            await this.core.storageAccess.writeHiddenFileAuto(this.testRootPath + "task.md", mod2Doc);
+        }
+
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+        await delay(1000);
+        if (await this.core.confirm.askYesNoDialog("Ready to check result?", { timeout: 30, defaultOption: "Yes" }) == "no") {
+            return;
+        }
+        await this.core.$$replicate();
+        await this.core.$$replicate();
+        const mergedDoc = `Tasks!
+- [ ] Task 1
+- [v] Task 2
+- [v] Task 3
+- [ ] Task 4
+`
+        return this.__assertStorageContent(this.testRootPath + "task.md" as FilePath, mergedDoc, false, true);
+    }
+
+    async checkConflictResolution() {
+        this._log("Before testing conflicted files, resolve all once", LOG_LEVEL_NOTICE);
+        await this.core.rebuilder.resolveAllConflictedFilesByNewerOnes();
+        await this.core.rebuilder.resolveAllConflictedFilesByNewerOnes();
+        await this.core.$$replicate();
+        await delay(1000);
+        if (!await this.testConflictAutomatic()) {
+            this._log("Conflict resolution (Auto) failed", LOG_LEVEL_NOTICE);
+            return false;
+        }
+        if (!await this.testConflictedManually1()) {
+            this._log("Conflict resolution (Manual1) failed", LOG_LEVEL_NOTICE);
+            return false;
+        }
+        if (!await this.testConflictedManually2()) {
+            this._log("Conflict resolution (Manual2) failed", LOG_LEVEL_NOTICE);
+            return false;
+        }
+        return true;
+
+    }
+
+
+    async __assertStorageContent(fileName: FilePath, content: string, inverted = false, showResult = false): Promise<boolean | string> {
+        try {
+            const fileContent = await this.core.storageAccess.readHiddenFileText(fileName);
+            let result = fileContent === content;
+            if (inverted) {
+                result = !result;
+            }
+            if (result) {
+                return true;
+            } else {
+                if (showResult) {
+                    this._log(`Content is not same \n Expected:${content}\n Actual:${fileContent}`, LOG_LEVEL_VERBOSE);
+                }
+                return `Content is not same \n Expected:${content}\n Actual:${fileContent}`;
+            }
+        } catch (e) {
+            this._log(`Cannot assert storage content: ${e}`);
+            return false;
+        }
+    }
+    async performTestManually() {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        await this.checkConflictResolution();
+        // await this.collectTestFiles();
+    }
+
+    // testResults = writable<[boolean, string, string][]>([]);
+    // testResults: string[] = [];
+
+    // $$addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void {
+    //     const logLine = `${name}: ${key} ${summary ?? ""}`;
+    //     this.testResults.update((results) => {
+    //         results.push([result, logLine, message ?? ""]);
+    //         return results;
+    //     });
+    // }
+    async $everyModuleTestMultiDevice(): Promise<boolean> {
+        if (!this.settings.enableDebugTools) return Promise.resolve(true);
+        // this.core.$$addTestResult("DevModule", "Test", true);
+        // return Promise.resolve(true);
+        await this._test("Conflict resolution", async () => await this.checkConflictResolution());
+        return this.testDone();
+    }
+}

src/modules/extras/devUtil/TestPane.svelte

@@ -0,0 +1,119 @@
+<script lang="ts">
+    import { onDestroy, onMount } from "svelte";
+    import type ObsidianLiveSyncPlugin from "../../../main.ts";
+    import { perf_trench } from "./tests.ts";
+    import { MarkdownRenderer, Notice } from "../../../deps.ts";
+    import type { ModuleDev } from "../ModuleDev.ts";
+    import { fireAndForget } from "octagonal-wheels/promises";
+    import { EVENT_LAYOUT_READY, eventHub } from "../../../common/events.ts";
+    import { writable } from "svelte/store";
+    export let plugin: ObsidianLiveSyncPlugin;
+    export let moduleDev: ModuleDev;
+    let performanceTestResult = "";
+    let functionCheckResult = "";
+    let testRunning = false;
+    let prefTestResultEl: HTMLDivElement;
+    let isReady = false;
+    $: {
+        if (performanceTestResult != "" && isReady) {
+            MarkdownRenderer.render(plugin.app, performanceTestResult, prefTestResultEl, "/", plugin);
+        }
+    }
+
+    async function performTest() {
+        try {
+            testRunning = true;
+            performanceTestResult = await perf_trench(plugin);
+        } finally {
+            testRunning = false;
+        }
+    }
+    function clearResult() {
+        moduleDev.testResults.update((v) => {
+            v = [];
+            return v;
+        });
+    }
+    function clearPerfTestResult() {
+        prefTestResultEl.empty();
+    }
+    onMount(async () => {
+        isReady = true;
+        // performTest();
+
+        eventHub.once(EVENT_LAYOUT_READY, async () => {
+            if (await plugin.storageAccess.isExistsIncludeHidden("_AUTO_TEST.md")) {
+                new Notice("Auto test file found, running tests...");
+                fireAndForget(async () => {
+                    await allTest();
+                });
+            } else {
+                // new Notice("No auto test file found, skipping tests...");
+            }
+        });
+    });
+
+    let moduleTesting = false;
+    function moduleMultiDeviceTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        plugin.$everyModuleTestMultiDevice().finally(() => {
+            moduleTesting = false;
+        });
+    }
+    function moduleSingleDeviceTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        plugin.$everyModuleTest().finally(() => {
+            moduleTesting = false;
+        });
+    }
+    async function allTest() {
+        if (moduleTesting) return;
+        moduleTesting = true;
+        try {
+            await plugin.$everyModuleTest();
+            await plugin.$everyModuleTestMultiDevice();
+        } finally {
+            moduleTesting = false;
+        }
+    }
+
+    const results = moduleDev.testResults;
+    $: resultLines = $results;
+
+    let syncStatus = [] as string[];
+    eventHub.on<string[]>("debug-sync-status", (status) => {
+        syncStatus = [...status];
+    });
+</script>
+
+<h2>TESTING BENCH: Self-hosted LiveSync</h2>
+
+<h3>Module Checks</h3>
+<button on:click={() => moduleMultiDeviceTest()} disabled={moduleTesting}>MultiDevice Test</button>
+<button on:click={() => moduleSingleDeviceTest()} disabled={moduleTesting}>SingleDevice Test</button>
+<button on:click={() => allTest()} disabled={moduleTesting}>All Test</button>
+<button on:click={() => clearResult()}>Clear</button>
+
+{#each resultLines as [result, line, message]}
+    <details open={!result}>
+        <summary>[{result ? "PASS" : "FAILED"}] {line}</summary>
+        <pre>{message}</pre>
+    </details>
+{/each}
+
+<h3>Synchronisation Result Status</h3>
+<pre>{syncStatus.join("\n")}</pre>
+
+<h3>Performance test</h3>
+<button on:click={() => performTest()} disabled={testRunning}>Test!</button>
+<button on:click={() => clearPerfTestResult()}>Clear</button>
+
+<div bind:this={prefTestResultEl}></div>
+
+<style>
+    * {
+        box-sizing: border-box;
+    }
+</style>

src/modules/extras/devUtil/TestPaneView.ts

@@ -0,0 +1,55 @@
+import {
+    ItemView,
+    WorkspaceLeaf
+} from "obsidian";
+import TestPaneComponent from "./TestPane.svelte"
+import type ObsidianLiveSyncPlugin from "../../../main.ts"
+import type { ModuleDev } from "../ModuleDev.ts";
+export const VIEW_TYPE_TEST = "ols-pane-test";
+//Log view
+export class TestPaneView extends ItemView {
+
+    component?: TestPaneComponent;
+    plugin: ObsidianLiveSyncPlugin;
+    moduleDev: ModuleDev;
+    icon = "view-log";
+    title: string = "Self-hosted LiveSync Test and Results"
+    navigation = true;
+
+    getIcon(): string {
+        return "view-log";
+    }
+
+    constructor(leaf: WorkspaceLeaf, plugin: ObsidianLiveSyncPlugin, moduleDev: ModuleDev) {
+        super(leaf);
+        this.plugin = plugin;
+        this.moduleDev = moduleDev;
+    }
+
+
+    getViewType() {
+        return VIEW_TYPE_TEST;
+    }
+
+    getDisplayText() {
+        return "Self-hosted LiveSync Test and Results";
+    }
+
+    // eslint-disable-next-line require-await
+    async onOpen() {
+        this.component = new TestPaneComponent({
+            target: this.contentEl,
+            props: {
+                plugin: this.plugin,
+                moduleDev: this.moduleDev
+            },
+        });
+        await Promise.resolve();
+    }
+
+    // eslint-disable-next-line require-await
+    async onClose() {
+        this.component?.$destroy();
+        await Promise.resolve();
+    }
+}

src/modules/extras/devUtil/testUtils.ts

@@ -0,0 +1,46 @@
+import { fireAndForget } from "../../../lib/src/common/utils.ts";
+import { serialized } from "../../../lib/src/concurrency/lock.ts";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+
+let plugin: ObsidianLiveSyncPlugin;
+export function enableTestFunction(plugin_: ObsidianLiveSyncPlugin) {
+    plugin = plugin_;
+}
+export function addDebugFileLog(message: any, stackLog = false) {
+    fireAndForget(serialized("debug-log", async () => {
+        const now = new Date();
+        const filename = `debug-log`
+        const time = now.toISOString().split("T")[0];
+        const outFile = `${filename}${time}.jsonl`;
+        // const messageContent = typeof message == "string" ? message : message instanceof Error ? `${message.name}:${message.message}` : JSON.stringify(message, null, 2);
+        const timestamp = now.toLocaleString();
+        const timestampEpoch = now;
+        let out = { "timestamp": timestamp, epoch: timestampEpoch, } as Record<string, any>;
+        if (message instanceof Error) {
+            // debugger;
+            // console.dir(message.stack);
+            out = { ...out, message };
+        } else if (stackLog) {
+            if (stackLog) {
+                const stackE = new Error();
+                const stack = stackE.stack;
+                out = { ...out, stack }
+            }
+        }
+        if (typeof message == "object") {
+            out = { ...out, ...message, }
+        } else {
+            out = {
+                result: message
+            }
+        }
+        // const out = "--" + timestamp + "--\n" + messageContent + " " + (stack || "");
+        // const out
+        try {
+            await plugin.storageAccess.appendHiddenFile(plugin.app.vault.configDir + "/ls-debug/" + outFile, JSON.stringify(out) + "\n")
+        } catch {
+
+            //NO OP
+        }
+    }));
+}

src/modules/extras/devUtil/tests.ts

@@ -0,0 +1,71 @@
+import { Trench } from "../../../lib/src/memory/memutil.ts";
+import type ObsidianLiveSyncPlugin from "../../../main.ts";
+type MeasureResult = [times: number, spent: number];
+type NamedMeasureResult = [name: string, result: MeasureResult];
+const measures = new Map<string, MeasureResult>();
+
+function clearResult(name: string) {
+    measures.set(name, [0, 0]);
+}
+async function measureEach(name: string, proc: () => (void | Promise<void>)) {
+    const [times, spent] = measures.get(name) ?? [0, 0];
+
+    const start = performance.now();
+    const result = proc();
+    if (result instanceof Promise) await result;
+    const end = performance.now();
+    measures.set(name, [times + 1, spent + (end - start)]);
+
+}
+function formatNumber(num: number) {
+    return num.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+async function measure(name: string, proc: () => (void | Promise<void>), times: number = 10000, duration: number = 1000): Promise<NamedMeasureResult> {
+    const from = Date.now();
+    let last = times;
+    clearResult(name);
+    do {
+        await measureEach(name, proc);
+    } while (last-- > 0 && (Date.now() - from) < duration)
+    return [name, measures.get(name) as MeasureResult];
+}
+
+// eslint-disable-next-line require-await, @typescript-eslint/require-await
+async function formatPerfResults(items: NamedMeasureResult[]) {
+    return `| Name | Runs | Each | Total |\n| --- | --- | --- | --- | \n` + items.map(e => `| ${e[0]} | ${e[1][0]} | ${e[1][0] != 0 ? formatNumber(e[1][1] / e[1][0]) : "-"} | ${formatNumber(e[1][0])} |`).join("\n");
+
+}
+export async function perf_trench(plugin: ObsidianLiveSyncPlugin) {
+    clearResult("trench");
+    const trench = new Trench(plugin.simpleStore);
+    const result = [] as NamedMeasureResult[];
+    result.push(await measure("trench-short-string", async () => {
+        const p = trench.evacuate("string");
+        await p();
+    }));
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/10kb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-10kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/100kb.jpeg");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-100kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.storageAccess.readHiddenFileBinary("testdata/1mb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-1mb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    return formatPerfResults(result);
+}