Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
test: add limit monotonicity and partial-evidence regressions
N0zoM1z04afd97029c3e
diff --git a/tests/coverageMonotonicity.test.ts b/tests/coverageMonotonicity.test.tsnew file mode 100644index 000000000..203020b41--- /dev/null+++ b/tests/coverageMonotonicity.test.ts@@ -0,0 +1,260 @@+import { createHash } from "node:crypto";++import { fc, it } from "@fast-check/vitest";+import { describe, expect } from "vitest";++import type { BinaryTarget } from "../src/domain/binaryTarget.js";+import {+ assessManagedGraphOmissions,+ managedGraphEvidenceCoverage,+ totalManagedGraphOmitted,+ type ManagedGraphProjectionLimits,+} from "../src/domain/managedApplicationGraphCoverage.js";+import {+ assessKnownPageCoverage,+ type KnownCollectionPage,+} from "../src/domain/knownPageCoverage.js";+import { inspectManagedMembersBytes } from "../src/dotnet/ManagedMemberInspector.js";+import { inspectManagedNativeBoundariesBytes } from "../src/dotnet/ManagedNativeBoundaryInspector.js";+import { buildManagedPeFixture } from "./fixtures/managedPe.js";++const MEMBER_LIMITS = {+ typeOffset: 0,+ typeLimit: 100,+ methodOffset: 0,+ methodLimit: 100,+ fieldOffset: 0,+ fieldLimit: 100,+ memberRefOffset: 0,+ memberRefLimit: 100,+ edgeOffset: 0,+ edgeLimit: 100,+ instructionAnchorLimit: 100,+ maxMetadataBytes: 1024 * 1024,+ maxTableRows: 1_000,+ maxHeapItemBytes: 1024 * 1024,+ maxMethodBodyBytes: 1024 * 1024,+ maxMethodInstructions: 1_000,+};++const BOUNDARY_LIMITS = {+ moduleRefOffset: 0,+ moduleRefLimit: 100,+ importOffset: 0,+ importLimit: 100,+ implementationOffset: 0,+ implementationLimit: 100,+ maxMetadataBytes: 1024 * 1024,+ maxTableRows: 1_000,+ maxHeapItemBytes: 1024 * 1024,+};++const limitPair = fc+ .tuple(fc.integer({ min: 1, max: 12 }), fc.integer({ min: 1, max: 12 }))+ .map(+ ([first, second]) =>+ [Math.min(first, second), Math.max(first, second)] as const,+ );++describe("coverage monotonicity", () => {+ it.prop([fc.integer({ min: 0, max: 200 }), limitPair])(+ "never makes a smaller source page more complete",+ (total, [smallerLimit, largerLimit]) => {+ const smaller = assessKnownPageCoverage(sourcePage(total, smallerLimit));+ const larger = assessKnownPageCoverage(sourcePage(total, largerLimit));++ expect(smaller.includedCount).toBeLessThanOrEqual(larger.includedCount);+ expect(smaller.omittedCount).toBeGreaterThanOrEqual(larger.omittedCount);+ expect(smaller.sourceOmittedCount).toBeGreaterThanOrEqual(+ larger.sourceOmittedCount,+ );+ if (smaller.complete) expect(larger.complete).toBe(true);+ },+ );++ it.prop([fc.integer({ min: 0, max: 200 }), limitPair])(+ "never makes a smaller downstream projection more complete",+ (total, [smallerLimit, largerLimit]) => {+ const page = sourcePage(total, Math.max(1, total));+ const smaller = assessKnownPageCoverage(page, smallerLimit);+ const larger = assessKnownPageCoverage(page, largerLimit);++ expect(smaller.includedCount).toBeLessThanOrEqual(larger.includedCount);+ expect(smaller.omittedCount).toBeGreaterThanOrEqual(larger.omittedCount);+ expect(smaller.sourceComplete).toBe(larger.sourceComplete);+ if (smaller.complete) expect(larger.complete).toBe(true);+ },+ );++ it.prop([+ fc.array(fc.integer({ min: 0, max: 12 }), {+ minLength: 5,+ maxLength: 5,+ }),+ fc.array(limitPair, { minLength: 5, maxLength: 5 }),+ ])(+ "does not improve aggregate managed graph coverage when projection limits shrink",+ (totals, pairs) => {+ const sources = managedSources(totals);+ const smaller = assessManagedGraphOmissions(+ sources,+ graphLimits(pairs, 0),+ );+ const larger = assessManagedGraphOmissions(+ sources,+ graphLimits(pairs, 1),+ );+ const smallerCoverage = managedGraphEvidenceCoverage(smaller);+ const largerCoverage = managedGraphEvidenceCoverage(larger);++ expect(totalManagedGraphOmitted(smaller)).toBeGreaterThanOrEqual(+ totalManagedGraphOmitted(larger),+ );+ expect(smaller.types).toBeGreaterThanOrEqual(larger.types);+ expect(smaller.methods).toBeGreaterThanOrEqual(larger.methods);+ expect(smaller.fields).toBeGreaterThanOrEqual(larger.fields);+ expect(smaller.pinvokeImports).toBeGreaterThanOrEqual(+ larger.pinvokeImports,+ );+ expect(smaller.nativeImplementations).toBeGreaterThanOrEqual(+ larger.nativeImplementations,+ );+ if (smallerCoverage.status === "complete")+ expect(largerCoverage.status).toBe("complete");+ },+ );++ it("does not let wider projection limits repair parser-unknown input", () => {+ const sources = managedSources([2, 2, 2, 2, 2]);+ const partialSources = {+ ...sources,+ members: {+ ...sources.members,+ coverage: {+ state: "partial" as const,+ issues: [+ {+ code: "limit-exceeded" as const,+ scope: "method.0x06000001.body.instructions",+ offset: 0x0a00,+ detail: "instruction limit reached",+ },+ ],+ },+ },+ };+ const narrow = managedGraphEvidenceCoverage(+ assessManagedGraphOmissions(partialSources, constantGraphLimits(1)),+ );+ const wide = managedGraphEvidenceCoverage(+ assessManagedGraphOmissions(partialSources, constantGraphLimits(100)),+ );++ expect(narrow).toMatchObject({+ status: "partial",+ truncated: false,+ omitted_count: null,+ });+ expect(wide).toEqual(narrow);+ });+});++const sourcePage = (+ total: number,+ limit: number,+): KnownCollectionPage<number> => {+ const returned = Math.min(total, limit);+ return {+ items: Array.from({ length: returned }, (_, index) => index),+ offset: 0,+ limit,+ total,+ returned,+ complete: returned === total,+ };+};++const fixtureBytes = buildManagedPeFixture({+ pinvoke: {+ moduleName: "user32.dll",+ importName: "MessageBoxW",+ mappingFlags: 0x0345,+ },+ readyToRun: true,+});+const fixtureTarget: BinaryTarget = {+ path: "/fixture/ManagedCoverage.exe",+ sha256: createHash("sha256").update(fixtureBytes).digest("hex"),+ kind: "executable",+ format: "pe",+ architecture: "x86",+ availableArchitectures: ["x86"],+};+const fixtureMembers = inspectManagedMembersBytes(+ fixtureBytes,+ fixtureTarget,+ MEMBER_LIMITS,+);+const fixtureBoundaries = inspectManagedNativeBoundariesBytes(+ fixtureBytes,+ fixtureTarget,+ BOUNDARY_LIMITS,+);++const managedSources = (totals: readonly number[]) => ({+ artifact: null,+ members: {+ ...fixtureMembers,+ types: repeatPage(fixtureMembers.types, totals[0] ?? 0),+ methods: repeatPage(fixtureMembers.methods, totals[1] ?? 0),+ fields: repeatPage(fixtureMembers.fields, totals[2] ?? 0),+ },+ boundaries: {+ ...fixtureBoundaries,+ pinvoke_imports: repeatPage(+ fixtureBoundaries.pinvoke_imports,+ totals[3] ?? 0,+ ),+ native_implementations: repeatPage(+ fixtureBoundaries.native_implementations,+ totals[4] ?? 0,+ ),+ },+});++const repeatPage = <Item, Page extends KnownCollectionPage<Item>>(+ page: Page,+ total: number,+) => {+ const first = page.items[0];+ const items =+ first === undefined ? [] : Array.from({ length: total }, () => first);+ return {+ ...page,+ items,+ offset: 0,+ limit: Math.max(1, total),+ total,+ returned: total,+ complete: true,+ };+};++const graphLimits = (+ pairs: readonly (readonly [number, number])[],+ index: 0 | 1,+): ManagedGraphProjectionLimits => ({+ max_types: pairs[0]?.[index] ?? 1,+ max_methods: pairs[1]?.[index] ?? 1,+ max_fields: pairs[2]?.[index] ?? 1,+ max_pinvoke_imports: pairs[3]?.[index] ?? 1,+ max_native_implementations: pairs[4]?.[index] ?? 1,+});++const constantGraphLimits = (value: number): ManagedGraphProjectionLimits => ({+ max_types: value,+ max_methods: value,+ max_fields: value,+ max_pinvoke_imports: value,+ max_native_implementations: value,+});diff --git a/tests/javascriptArtifactReconstruction.test.ts b/tests/javascriptArtifactReconstruction.test.tsindex 9f150efc4..fa09dfc1a 100644--- a/tests/javascriptArtifactReconstruction.test.ts+++ b/tests/javascriptArtifactReconstruction.test.ts@@ -365,10 +365,14 @@ describe("JavaScript artifact reconstruction", () => {const root = await mkdtemp(join(tmpdir(), "rea-javascript-ast-limit-"));await writeFile(join(root, "large.js"),- Array.from(- { length: 100 },- (_, index) => `export const value${String(index)} = ${String(index)};`,- ).join("\n"),+ [+ 'import "./unobserved.js";',+ ...Array.from(+ { length: 100 },+ (_, index) =>+ `export const value${String(index)} = ${String(index)};`,+ ),+ ].join("\n"),);const result = await reconstructJavaScriptArtifact({@@ -383,6 +387,18 @@ describe("JavaScript artifact reconstruction", () => {truncated: true,omitted_count: null,});+ const derivedImport = result.graph.edges.find(+ ({ relation, properties }) =>+ relation === "imports" && properties.specifier === "./unobserved.js",+ );+ expect(derivedImport?.evidence.coverage).toEqual({+ status: "partial",+ truncated: true,+ omitted_count: null,+ limits: expect.arrayContaining([+ { name: "max-ast-nodes", value: 50, unit: "items" },+ ]),+ });});it("does not follow symlinks or read oversized JavaScript text", async () => {