Files
reverse-engineering-anything/tests/boundary/filesystem/callerPath.test.ts
T
morluto 422cff00ab refactor(process): give POSIX PATH search order one owner (#10891)
* refactor(process): give POSIX PATH search order one owner

Program lookup, the packet-tool locator and Jadx's Java lookup each split
PATH and resolved empty and relative entries themselves. They now take the
candidates from posixPathCandidates in src/process/executableSearch and keep
only their own probe and failure reporting. A counted architecture guard
keeps new PATH splits from returning; the remaining Windows and Ghidra
searches are baselined.

* refactor(process): move the colon-split PATH searches onto the search owner

REA's launcher-alias lookup and Ghidra's macOS Java lookup split PATH on
":" and skipped relative entries themselves; they now use
posixPathCandidates with relativeEntries: "skip", and the guard counts
colon splits of PATH as well.

* fix(process): produce PATH candidates lazily so an unused entry cannot fail an earlier match

* refactor(process): give Windows PATH/PATHEXT search order the executable search owner (#10916)

* refactor(process): give Windows PATH/PATHEXT search order the executable search owner

* fix(process): keep later PATH entries searchable after a stray quote or a removed working directory

* fix(reverse): refuse a Windows objdump or Rizin command that PATH does not find (#10953)

* fix(reverse): refuse an objdump or Rizin command Windows PATH does not find instead of launching the bare name

* fix(reverse): report a Windows lookup refusal after cancellation and to capability discovery

* fix(desktop): search a Windows host's PATH as Windows does when doctor looks up a program

programOnPath sent every host through the POSIX PATH search, so on Windows a
relative PATH entry reached absoluteCallerPath with platform linux and the
Windows working directory, which resolved against itself until the stack
overflowed. programOnPath now searches PATH and PATHEXT through
windowsPathCandidates on a Windows host, and absoluteCallerPath refuses a
non-POSIX working directory with a TypeError instead of recursing.
2026-11-15 18:24:04 +08:00

102 lines
3.6 KiB
TypeScript

import { expect, it, vi } from "vitest";
import { absoluteCallerPath } from "../../../src/filesystem/callerPath.js";
it("resolves absolute POSIX paths independently of an unavailable cwd", () => {
const cwd = vi.spyOn(process, "cwd").mockImplementation(() => {
throw new Error("working directory was removed");
});
try {
expect(
absoluteCallerPath("/cache//rea/kuna/.", { platform: "linux" }),
).toBe("/cache/rea/kuna/");
expect(
absoluteCallerPath("sample", { cwd: "/explicit", platform: "linux" }),
).toBe("/explicit/sample");
} finally {
cwd.mockRestore();
}
});
it("keeps POSIX parent components for the filesystem to resolve", () => {
const posix = { cwd: "/work", platform: "linux" } as const;
expect(absoluteCallerPath("link/../sample", posix)).toBe(
"/work/link/../sample",
);
expect(absoluteCallerPath("/abs/link/../sample", posix)).toBe(
"/abs/link/../sample",
);
expect(absoluteCallerPath("../sample", posix)).toBe("/work/../sample");
});
it("removes only POSIX spellings that cannot change the named file", () => {
const posix = { cwd: "/work/", platform: "darwin" } as const;
expect(absoluteCallerPath("./module.wasm", posix)).toBe("/work/module.wasm");
expect(absoluteCallerPath("a//./b", posix)).toBe("/work/a/b");
expect(absoluteCallerPath("/x/./y", posix)).toBe("/x/y");
expect(absoluteCallerPath("sample", { ...posix, cwd: "/" })).toBe("/sample");
expect(absoluteCallerPath("/", posix)).toBe("/");
// A trailing separator or `.` still requires a directory.
expect(absoluteCallerPath("sample/", posix)).toBe("/work/sample/");
expect(absoluteCallerPath("sample/.", posix)).toBe("/work/sample/");
expect(absoluteCallerPath("a//b//", posix)).toBe("/work/a/b/");
});
it("makes a relative POSIX cwd absolute before appending the path", () => {
const cwd = vi.spyOn(process, "cwd").mockReturnValue("/work");
try {
expect(
absoluteCallerPath("sample", { cwd: "fixtures/../x", platform: "linux" }),
).toBe("/work/fixtures/../x/sample");
} finally {
cwd.mockRestore();
}
});
it("uses lexical resolution on Windows, where it is exact", () => {
const win32 = { cwd: "C:\\work", platform: "win32" } as const;
expect(absoluteCallerPath("link\\..\\sample", win32)).toBe(
"C:\\work\\sample",
);
expect(absoluteCallerPath("D:\\x\\..\\y", win32)).toBe("D:\\y");
});
it("normalizes separator spellings of absolute Windows paths (#4707)", () => {
const win32 = { cwd: "C:\\work", platform: "win32" } as const;
for (const spelling of [
"C:\\Users\\u\\h.exe",
"C:/Users/u/h.exe",
"C:\\\\Users\\\\u\\\\h.exe",
"C://Users//u//h.exe",
])
expect(absoluteCallerPath(spelling, win32)).toBe("C:\\Users\\u\\h.exe");
});
it("keeps unselected Windows share paths lexical", () => {
expect(
absoluteCallerPath("\\\\unselected-server\\share\\Source.JS", {
platform: "win32",
}),
).toBe("\\\\unselected-server\\share\\Source.JS");
expect(
absoluteCallerPath("C:\\CaseSensitive\\Different.js", {
platform: "win32",
}),
).toBe("C:\\CaseSensitive\\Different.js");
});
it("refuses POSIX resolution from a Windows working directory instead of recursing", () => {
const cwd = vi.spyOn(process, "cwd").mockReturnValue("C:\\work");
try {
// A POSIX PATH search on a Windows host reached this with a relative entry.
expect(() => absoluteCallerPath("bin/uv", { platform: "linux" })).toThrow(
TypeError,
);
expect(() =>
absoluteCallerPath("bin/uv", { cwd: "relative", platform: "linux" }),
).toThrow(TypeError);
} finally {
cwd.mockRestore();
}
});