import { describe, expect, it } from "vitest"; import { inspectManagedMembersBytes } from "./ManagedMemberInspector.js"; import { ManagedDecodeBudget } from "./ManagedDecodeBudget.js"; import { edges } from "./ManagedMemberRows.js"; import { signature, type ManagedMethod } from "./ManagedMemberInspectorCore.js"; import { ManagedReaderFailure } from "./ManagedReaderFailure.js"; import { managedMemberInspectionSchema } from "../domain/managed/managedArtifact.js"; import { comparisonLimitations } from "../domain/managed/managedMemberComparisonCoverage.js"; import { buildManagedPeFixture, buildNativePeFixture, managedPeFixtureTarget, } from "./ManagedPe.fixture.js"; describe("managed member inspection", () => { it("keeps metadata handles distinct from calls and field accesses", () => { const il = Buffer.from([ 0xd0, 0x01, 0, 0, 0x06, 0x26, 0xd0, 0x01, 0, 0, 0x04, 0x26, 0x28, 0x01, 0, 0, 0x0a, 0x7b, 0x01, 0, 0, 0x04, 0x26, 0x2a, ]); const bytes = buildManagedPeFixture({ ilBody: Buffer.concat([Buffer.from([(il.length << 2) | 2]), il]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.methods[0]?.body.anchors.map(({ opcode }) => opcode)).toEqual( ["ldtoken", "ldtoken", "call", "ldfld"], ); expect(result.call_edges.map(({ opcode }) => opcode)).toEqual(["call"]); expect(result.field_accesses.map(({ opcode }) => opcode)).toEqual([ "ldfld", ]); }); it("inspects metadata members, signatures, CIL hashes, call edges, and field anchors", () => { const bytes = buildManagedPeFixture(); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.identity_scope).toEqual({ token_identity: "build-local", requires_artifact_sha256: managedPeFixtureTarget(bytes).sha256, requires_mvid: "00112233-4455-6677-8899-aabbccddeeff", }); expect(result.types).toEqual([ expect.objectContaining({ token: "0x02000001", full_name: "Fixture.Program", field_list: { first_row: 1, last_row: 1, count: 1 }, method_list: { first_row: 1, last_row: 1, count: 1 }, }), ]); expect(result.fields).toEqual([ expect.objectContaining({ token: "0x04000001", declaring_type: "Fixture.Program", name: "counter", signature: expect.objectContaining({ kind: "field", parse_status: "decoded", field_type: "i4", }), }), ]); expect(result.methods).toEqual([ expect.objectContaining({ token: "0x06000001", declaring_type: "Fixture.Program", name: "Main", rva: 0x2800, signature: expect.objectContaining({ kind: "method", parse_status: "decoded", return_type: "void", parameter_types: [], }), body: expect.objectContaining({ status: "present", header_format: "tiny", file_offset: 0x0a00, il_size: 12, instruction_count: 4, decoded_instruction_count: 4, truncated_instructions: 0, opcode_counts: { "ldarg.0": 1, ldfld: 1, call: 1, ret: 1 }, anchors: [ { il_offset: 1, opcode: "ldfld", operand_kind: "field", operand: "0x04000001", }, { il_offset: 6, opcode: "call", operand_kind: "method", operand: "0x0a000001", }, ], }), }), ]); expect(result.member_refs).toEqual([ expect.objectContaining({ token: "0x0a000001", name: ".ctor", signature: expect.objectContaining({ kind: "method", parse_status: "decoded", parameter_types: ["string"], }), }), ]); expect(result.call_edges).toEqual([ { caller_token: "0x06000001", caller: "Fixture.Program.Main", opcode: "call", target_token: "0x0a000001", target_kind: "member-ref", target_name: ".ctor", }, ]); expect(result.field_accesses).toEqual([ { method_token: "0x06000001", method: "Fixture.Program.Main", opcode: "ldfld", field_token: "0x04000001", field_name: "counter", }, ]); expect(result.coverage).toMatchObject({ state: "complete", issues: [] }); }); }); describe("managed exported types", () => { it("reports type forwarders and nested exported types with their implementation scope", () => { const bytes = buildManagedPeFixture({ exportedTypes: [ { namespace: "System", name: "Object", flags: 0x0020_0001, implementationRaw: (1 << 2) | 1, }, { namespace: "", name: "Enumerator", flags: 0x0000_0002, implementationRaw: (1 << 2) | 2, }, ], }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.metadata.table_row_counts).toMatchObject({ ExportedType: 2, }); expect(result.exported_types).toMatchObject([ { token: "0x27000001", namespace: "System", name: "Object", flags: 0x0020_0001, forwarder: true, type_def_id: 0, implementation_token: "0x23000001", }, { token: "0x27000002", namespace: "", name: "Enumerator", forwarder: false, implementation_token: "0x27000001", }, ]); expect(result.coverage).toEqual({ state: "complete", issues: [] }); }); it("leaves exported types unknown when CLI metadata is unavailable", () => { const bytes = buildNativePeFixture(); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.coverage.state).toBe("unavailable"); expect(result.exported_types).toBeNull(); }); it("reads member Evidence recorded before exported types as unexamined", () => { const bytes = buildManagedPeFixture(); const { exported_types: _omitted, ...legacy } = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); const parsed = managedMemberInspectionSchema.parse(legacy); expect(parsed.exported_types).toBeNull(); expect(comparisonLimitations(parsed, parsed)).toContain( "At least one managed member observation predates ExportedType inspection; its exported and forwarded types are unknown.", ); }); it("retains an exported type whose implementation is out of range as partial", () => { const bytes = buildManagedPeFixture({ exportedTypes: [ { namespace: "System", name: "Object", flags: 0x0020_0001, implementationRaw: (9 << 2) | 1, }, ], }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.exported_types).toMatchObject([ { token: "0x27000001", name: "Object", implementation_token: null }, ]); expect(result.coverage).toMatchObject({ state: "partial", issues: [ { code: "invalid-row", scope: "metadata.ExportedType:0x27000001", detail: expect.stringContaining( "ExportedType implementation coded index 0x25 is invalid", ), }, ], }); }); }); describe("managed member decoding budget", () => { it("admits a wide-instruction method whose actual records fit the budget", () => { // Five-byte branches all target the next instruction. A final ret leaves // the method stack-neutral, despite over 256 KiB of valid IL bytes. const il = Buffer.alloc(270_001); for (let offset = 0; offset < il.length - 1; offset += 5) { il[offset] = 0x38; } il[il.length - 1] = 0x2a; const header = Buffer.alloc(12); header.writeUInt16LE(0x3003, 0); header.writeUInt16LE(8, 2); header.writeUInt32LE(il.length, 4); const bytes = buildManagedPeFixture({ ilBody: Buffer.concat([header, il]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.coverage).toMatchObject({ state: "complete", issues: [] }); expect(result.types).toHaveLength(1); expect(result.methods[0]?.body).toMatchObject({ status: "present", il_size: il.length, decoded_instruction_count: 54_001, opcode_counts: { br: 54_000, ret: 1 }, }); }); it("still rejects dense one-byte instructions before exceeding capacity", () => { // All NOPs: unlike wide instructions, each IL byte adds a decoded record. // A true oversized transient must remain an actionable resource limit. const il = Buffer.alloc(270_001); il[il.length - 1] = 0x2a; const header = Buffer.alloc(12); header.writeUInt16LE(0x3003, 0); header.writeUInt16LE(8, 2); header.writeUInt32LE(il.length, 4); const bytes = buildManagedPeFixture({ ilBody: Buffer.concat([header, il]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.coverage).toMatchObject({ state: "unavailable", issues: [{ code: "resource-limit", scope: "metadata.representation" }], }); // Report the originating IL coordinate, not a generic decoding error. expect(result.coverage.issues[0]?.offset).toBeGreaterThan(0); expect(result.types).toEqual([]); expect(result.methods).toEqual([]); }); it("charges decoded output rather than accumulated decoding bounds", () => { // Each bound fits alone, but 256 bytes per IL and signature byte together // exceed the 64 MiB budget although the retained members are small. const il = Buffer.concat([Buffer.alloc(200_000), Buffer.from([0x2a])]); const header = Buffer.alloc(12); header.writeUInt16LE(0x3003, 0); header.writeUInt16LE(8, 2); header.writeUInt32LE(il.length, 4); const bytes = buildManagedPeFixture({ ilBody: Buffer.concat([header, il]), methodSignature: Buffer.concat([ Buffer.from([0x00, 0x00, 0x01]), Buffer.alloc(80_000), ]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.coverage.state).not.toBe("unavailable"); expect(result.methods[0]?.body).toMatchObject({ status: "present", il_size: il.length, opcode_counts: { nop: 200_000, ret: 1 }, }); }); it("bounds a method's IL and exception sections together", () => { // Each bound fits alone; both stay live while one method is decoded. const il = Buffer.concat([Buffer.alloc(159_999), Buffer.from([0x2a])]); const header = Buffer.alloc(12); header.writeUInt16LE(0x300b, 0); header.writeUInt16LE(8, 2); header.writeUInt32LE(il.length, 4); const clauses = 110_000; const section = Buffer.alloc(4 + clauses * 24); section.writeUInt32LE(0x41 | ((4 + clauses * 24) << 8), 0); const bytes = buildManagedPeFixture({ ilBody: Buffer.concat([header, il, section]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.coverage).toMatchObject({ state: "unavailable", issues: [{ code: "resource-limit" }], }); }); }); describe("managed derived edges", () => { it("admits call edges before the derived graph exceeds the budget", () => { const anchor = { il_offset: 0, opcode: "call", operand_kind: "method", operand: "0x0a000001", }; const method = { token: "0x06000001", declaring_type: "T".repeat(2000), name: "m", body: { anchors: Array.from({ length: 40_000 }, () => anchor) }, } as unknown as ManagedMethod; expect(() => edges( [method], new Map(), new Map(), new Map(), new ManagedDecodeBudget(), ), ).toThrow(ManagedReaderFailure); }); }); describe("managed derived caller names", () => { it("admits a caller name before building it", () => { let built = false; // A string-like type name records whether the caller was interpolated. const declaringType = { length: 70 * 1024 * 1024, charCodeAt: () => 0x54, toString: () => { built = true; return "T"; }, } as unknown as string; const method = { token: "0x06000001", declaring_type: declaringType, name: "m", body: { anchors: [ { il_offset: 0, opcode: "call", operand_kind: "method", operand: "0x0a000001", }, ], }, } as unknown as ManagedMethod; expect(() => edges( [method], new Map(), new Map(), new Map(), new ManagedDecodeBudget(), ), ).toThrow(ManagedReaderFailure); expect(built).toBe(false); }); }); describe("managed member reference bounds", () => { it("retains members and reports an out-of-range TypeDef coded index as partial", () => { const bytes = buildManagedPeFixture({ extendsRaw: 12 }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.types[0]).toMatchObject({ token: "0x02000001", extends_token: null, }); expect(result.fields).toHaveLength(1); expect(result.methods).toHaveLength(1); expect(result.metadata.status).toBe("partial"); expect(result.coverage).toMatchObject({ state: "partial", issues: [ { code: "invalid-row", scope: "metadata.TypeDef:0x02000001", detail: expect.stringContaining( "TypeDef Extends coded index 0xc is invalid: coded index selects row 3 in table 2, which has 1 rows", ), }, ], }); expect(result.coverage.issues[0]?.offset).toBe( (result.types[0]?.row_offset ?? 0) + 8, ); }); it("retains a MemberRef with an out-of-range parent as an unknown partial reference", () => { const bytes = buildManagedPeFixture({ memberRefParentRaw: 40 }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.member_refs[0]).toMatchObject({ token: "0x0a000001", parent_token: null, name: ".ctor", }); expect(result.coverage).toMatchObject({ state: "partial", issues: [ { code: "invalid-row", scope: "metadata.MemberRef:0x0a000001", detail: expect.stringContaining( "MemberRef parent coded index 0x28 is invalid: coded index selects row 5 in table 2, which has 1 rows", ), }, ], }); expect(result.coverage.issues[0]?.offset).toBe( result.member_refs[0]?.row_offset, ); }); it("reports a null required MemberRef parent without dropping the reference", () => { const bytes = buildManagedPeFixture({ memberRefParentRaw: 0 }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.member_refs[0]).toMatchObject({ token: "0x0a000001", parent_token: null, }); expect(result.coverage).toMatchObject({ state: "partial", issues: [ expect.objectContaining({ code: "invalid-row", detail: "MemberRef parent coded index 0x0 is null, but the Class column must reference a row", }), ], }); }); it("decodes deeply nested supported pointer signatures without recursion", () => { const depth = 8_000; const bytes = buildManagedPeFixture({ fieldSignature: Buffer.concat([ Buffer.from([0x06]), Buffer.alloc(depth, 0x0f), Buffer.from([0x08]), ]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.fields[0]?.signature).toMatchObject({ kind: "field", parse_status: "decoded", field_type: `${"i4"}${"*".repeat(depth)}`, issue: null, }); expect(result.methods[0]?.body.status).toBe("present"); expect(result.coverage).toMatchObject({ state: "complete", issues: [] }); }); }); it.each([ Buffer.alloc(0), Buffer.from([0]), Buffer.from([0, 0, 0x12]), Buffer.from([0x10, 0x80]), Buffer.from([0, 0xe0]), ])( "marks incomplete or reserved method signatures malformed: %j", (methodSignature) => { const bytes = buildManagedPeFixture({ methodSignature }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.methods[0]?.signature).toMatchObject({ parse_status: "malformed", kind: "unknown", }); }, ); it("decodes generic instantiation member signatures as complete coverage", () => { // System.Runtime.Caching 0x06000001: instance void (Dictionary) // shape, with TypeRef/TypeSpec coded tokens kept as encoded. const bytes = buildManagedPeFixture({ methodSignature: Buffer.from([ 0x00, 0x01, 0x01, 0x15, 0x12, 0x71, 0x01, 0x0e, ]), fieldSignature: Buffer.from([ 0x06, 0x15, 0x11, 0x0a, 0x02, 0x13, 0x00, 0x1e, 0x01, ]), }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.methods[0]?.signature).toMatchObject({ parse_status: "decoded", return_type: "void", parameter_types: ["class:113"], issue: null, }); expect(result.fields[0]?.signature).toMatchObject({ parse_status: "decoded", field_type: "valuetype:10", }); expect(result.coverage).toMatchObject({ state: "complete", issues: [] }); }); it.each([ ["single-dimension general array", [0x14, 0x08, 0x01, 0x00, 0x00], "i4[...]"], [ "sized array with signed lower bounds", [0x14, 0x08, 0x02, 0x02, 0x04, 0x03, 0x02, 0x02, 0x7f], "i4[1...4,-1...1]", ], [ "partially bounded array", [0x14, 0x0e, 0x03, 0x01, 0x05, 0x00], "string[5,,]", ], [ "function pointer", [0x1b, 0x00, 0x02, 0x08, 0x0e, 0x1c], "fnptr[default](string,object)->i4", ], ["required modifier", [0x1f, 0x09, 0x08], "i4 modreq:9"], [ "optional modifier under a pointer", [0x0f, 0x20, 0x0d, 0x08], "i4 modopt:13*", ], [ "adjacent modifiers in source order", [0x1f, 0x05, 0x20, 0x09, 0x08], "i4 modreq:5 modopt:9", ], [ "modifier runs separated by a pointer", [0x1f, 0x05, 0x0f, 0x20, 0x09, 0x08], "i4 modopt:9* modreq:5", ], [ "unmanaged cdecl function pointer", [0x1b, 0x01, 0x01, 0x01, 0x18], "fnptr[c](native-int)->void", ], [ "array of generic instantiations", [0x1d, 0x15, 0x12, 0x05, 0x01, 0x14, 0x08, 0x01, 0x01, 0x03, 0x00], "class:5[]", ], ])("decodes a %s field signature", (_name, type, expected) => { expect(signature(Buffer.from([0x06, ...type]))).toMatchObject({ kind: "field", parse_status: "decoded", field_type: expected, issue: null, }); }); it.each([ ["generic instantiation without arguments", [0x15, 0x12, 0x05, 0x00]], ["generic instantiation of a primitive", [0x15, 0x08, 0x05, 0x01, 0x08]], ["zero-rank array", [0x14, 0x08, 0x00, 0x00, 0x00]], [ "array with more sizes than dimensions", [0x14, 0x08, 0x01, 0x02, 0x01, 0x01, 0x00], ], ["truncated generic argument list", [0x15, 0x12, 0x05, 0x02, 0x08]], ["truncated function pointer", [0x1b, 0x00, 0x01, 0x08]], ["function pointer with a field header", [0x1b, 0x06, 0x00, 0x01]], ["function pointer with a reserved flag", [0x1b, 0x80, 0x00, 0x01]], [ "function pointer with explicit-this but no has-this", [0x1b, 0x40, 0x00, 0x01], ], ["typed reference field", [0x16]], ["modified typed reference field", [0x20, 0x09, 0x16]], ["typed reference generic argument", [0x15, 0x12, 0x05, 0x01, 0x16]], ["typed reference array element", [0x1d, 0x16]], ["by-reference generic argument", [0x15, 0x12, 0x05, 0x01, 0x10, 0x08]], ["void generic argument", [0x15, 0x12, 0x05, 0x01, 0x01]], ["void function pointer parameter", [0x1b, 0x00, 0x01, 0x01, 0x01]], ["by-reference pointee", [0x0f, 0x10, 0x08]], ["nested by-reference", [0x10, 0x10, 0x08]], ["void field", [0x01]], ["void array element", [0x1d, 0x01]], ])("reports a %s as malformed", (_name, type) => { expect(signature(Buffer.from([0x06, ...type]))).toMatchObject({ kind: "unknown", parse_status: "malformed", }); }); it("rejects array ranks beyond the CLR limit before rendering dimensions", () => { expect( signature( Buffer.from([0x06, 0x14, 0x08, 0xdf, 0xff, 0xff, 0xff, 0x00, 0x00]), ), ).toMatchObject({ parse_status: "unsupported", issue: "array rank 536870911 exceeds the 32 dimensions the CLR supports", }); expect( signature(Buffer.from([0x06, 0x14, 0x08, 0x20, 0x00, 0x00])), ).toMatchObject({ parse_status: "decoded", field_type: `i4[${",".repeat(31)}]`, }); }); it("decodes typed references in parameter and return positions", () => { expect( signature(Buffer.from([0x00, 0x02, 0x16, 0x20, 0x09, 0x16, 0x08])), ).toMatchObject({ kind: "method", parse_status: "decoded", return_type: "typedbyref", parameter_types: ["typedbyref modopt:9", "i4"], }); expect( signature(Buffer.from([0x06, 0x1b, 0x20, 0x01, 0x01, 0x16])), ).toMatchObject({ parse_status: "decoded", field_type: "fnptr[default has-this](typedbyref)->void", }); }); it.each([ ["by-reference field", [0x06, 0x10, 0x08], { field_type: "i4&" }], ["void pointer field", [0x06, 0x0f, 0x01], { field_type: "void*" }], [ "by-reference function pointer return and parameter", [0x06, 0x1b, 0x00, 0x01, 0x10, 0x08, 0x10, 0x0e], { field_type: "fnptr[default](string&)->i4&" }, ], [ "by-reference method return and parameter", [0x00, 0x01, 0x10, 0x08, 0x10, 0x15, 0x12, 0x05, 0x01, 0x0f, 0x01], { return_type: "i4&", parameter_types: ["class:5&"] }, ], ])("decodes a %s in its grammar position", (_name, blob, expected) => { expect(signature(Buffer.from(blob))).toMatchObject({ parse_status: "decoded", ...expected, }); }); it("keeps element types that member signatures do not assign unsupported", () => { expect(signature(Buffer.from([0x06, 0x45, 0x08]))).toMatchObject({ parse_status: "unsupported", issue: "unsupported element type 0x45", }); }); it("decodes deeply nested generic instantiations without recursion", () => { const depth = 4_000; const decoded = signature( Buffer.concat([ Buffer.from([0x06]), Buffer.from( Array.from({ length: depth }, () => [0x15, 0x12, 0x05, 0x01]).flat(), ), Buffer.from([0x08]), ]), ); expect(decoded).toMatchObject({ parse_status: "decoded", field_type: `${"class:5<".repeat(depth)}i4${">".repeat(depth)}`, }); }); it("preserves leading U+FEFF as metadata name content", () => { const bytes = buildManagedPeFixture({ typeNamespace: "\uFEFFFixture", typeName: "\uFEFFProgram", methodName: "\uFEFFMain", fieldName: "\uFEFFcounter", }); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.types[0]?.full_name).toBe("\uFEFFFixture.\uFEFFProgram"); expect(result.methods[0]?.name).toBe("\uFEFFMain"); expect(result.fields[0]?.name).toBe("\uFEFFcounter"); expect(result.call_edges[0]?.caller).toBe( "\uFEFFFixture.\uFEFFProgram.\uFEFFMain", ); }); it.each([ { implFlags: 1, flags: 0, label: "native" }, { implFlags: 3, flags: 0, label: "runtime" }, { implFlags: 4, flags: 0, label: "unmanaged" }, { implFlags: 0, flags: 0x2000, label: "pinvoke" }, ])( "does not interpret $label implementations as CIL", ({ implFlags, flags }) => { const bytes = buildManagedPeFixture(); const original = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); const row = original.methods[0]?.row_offset; expect(row).toBeDefined(); if (row === undefined) return; bytes.writeUInt16LE(implFlags, row + 4); bytes.writeUInt16LE(bytes.readUInt16LE(row + 6) | flags, row + 6); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.methods[0]?.body).toMatchObject({ status: "partial", header_format: "unknown", rva: original.methods[0]?.rva, il_sha256: null, normalized_il_sha256: null, anchors: [], }); expect(result.methods[0]?.body.issue).toMatch(/CIL/u); expect(result.coverage.state).toBe("partial"); expect(result.call_edges).toEqual([]); expect(result.field_accesses).toEqual([]); }, ); it.each([ { facet: "fields", nameOffset: 2 }, { facet: "methods", nameOffset: 8 }, { facet: "member_refs", nameOffset: 2 }, { facet: "types", nameOffset: 4 }, ] as const)( "preserves independent metadata when a $facet name is unreadable", ({ facet, nameOffset }) => { const bytes = buildManagedPeFixture(); const original = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); const row = original[facet][0]?.row_offset; if (row === undefined) throw new Error(`Fixture must contain ${facet}`); bytes.writeUInt16LE(0xffff, row + nameOffset); const result = inspectManagedMembersBytes( bytes, managedPeFixtureTarget(bytes), ); expect(result.module?.mvid).toBe(original.module?.mvid); expect(result.metadata.status).toBe("partial"); expect(result[facet]).toEqual([]); for (const remaining of [ "fields", "methods", "member_refs", "types", ] as const) if (remaining !== facet) expect(result[remaining]).toHaveLength(original[remaining].length); expect(result.coverage).toMatchObject({ state: "partial", issues: [ expect.objectContaining({ code: "invalid-heap-index", scope: "metadata.#Strings", }), ], }); if (facet === "types") { expect(result.fields[0]).toMatchObject({ declaring_type_token: "0x02000001", declaring_type: null, }); expect(result.methods[0]).toMatchObject({ declaring_type_token: "0x02000001", declaring_type: null, }); } }, ); describe("managed member type selection", () => { const bytes = buildManagedPeFixture(); const target = managedPeFixtureTarget(bytes); const everything = inspectManagedMembersBytes(bytes, target); it("reports no selection when every type is inspected", () => { expect(everything.selection).toBeNull(); }); it("decodes the selected type's members and reports unmatched names", () => { const result = inspectManagedMembersBytes(bytes, target, { typeNames: ["Fixture.Program", "Missing.Type"], }); expect(result.selection).toEqual({ type_names: ["Fixture.Program", "Missing.Type"], unmatched_type_names: ["Missing.Type"], }); expect(result.types).toEqual(everything.types); expect(result.fields).toEqual(everything.fields); expect(result.methods).toEqual(everything.methods); expect(result.call_edges).toEqual(everything.call_edges); expect(result.field_accesses).toEqual(everything.field_accesses); expect(result.coverage).toEqual(everything.coverage); expect(result.limitations).toContain( "Types, fields, methods, call edges, and field accesses cover only the selected declaring types; coverage describes that selection. Edge targets outside it keep their names but are not described.", ); }); it("does not treat a name as absent when a TypeDef name is unreadable", () => { const corrupt = Buffer.from(bytes); const row = everything.types[0]?.row_offset ?? 0; // Point the TypeDef Name past the #Strings heap. corrupt.writeUInt16LE(0xffff, row + 4); const result = inspectManagedMembersBytes( corrupt, managedPeFixtureTarget(corrupt), { typeNames: ["Fixture.Program"] }, ); expect(result.selection?.unmatched_type_names).toEqual(["Fixture.Program"]); expect(result.coverage.state).toBe("partial"); expect(result.limitations).toContain( "1 TypeDef name(s) could not be read; a name in selection.unmatched_type_names may belong to one of them, so its absence is not observed.", ); }); it("omits members of unselected types without dropping member references", () => { const result = inspectManagedMembersBytes(bytes, target, { typeNames: ["Missing.Type"], }); expect(result.selection).toEqual({ type_names: ["Missing.Type"], unmatched_type_names: ["Missing.Type"], }); expect(result.types).toEqual([]); expect(result.fields).toEqual([]); expect(result.methods).toEqual([]); expect(result.call_edges).toEqual([]); expect(result.field_accesses).toEqual([]); expect(result.member_refs).toEqual(everything.member_refs); }); });