From ce0e3b3b9e4ec294ae155aee558912768f0fe2b1 Mon Sep 17 00:00:00 2001 From: ShuaixinHuang <1836656514@qq.com> Date: Thu, 19 Nov 2026 13:10:24 +0800 Subject: [PATCH] test(python): pin CPython code-object equality controls (#12040) --- tests/acceptance/pythonPycCli.test.ts | 27 ++++++ .../fixtures/python-pyc-equality/golden.json | 40 +++++++++ tests/fixtures/python-pyc-equality/golden.ts | 20 +++++ tests/fixtures/python-pyc-equality/produce.py | 87 +++++++++++++++++++ 4 files changed, 174 insertions(+) create mode 100644 tests/fixtures/python-pyc-equality/golden.json create mode 100644 tests/fixtures/python-pyc-equality/golden.ts create mode 100644 tests/fixtures/python-pyc-equality/produce.py diff --git a/tests/acceptance/pythonPycCli.test.ts b/tests/acceptance/pythonPycCli.test.ts index 430f522978..85cdbf663b 100644 --- a/tests/acceptance/pythonPycCli.test.ts +++ b/tests/acceptance/pythonPycCli.test.ts @@ -11,11 +11,38 @@ import { } from "../../src/python/PythonPyc.fixture.js"; import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js"; import { cliTest } from "../support/cli/cliFixture.js"; +import { pythonPycEqualityGolden } from "../fixtures/python-pyc-equality/golden.js"; const completePycEvidenceSchema = toolContract( "inspect_python_pyc", ).outputSchema.safeExtend({ normalized_result: pythonPycSchema }); +cliTest( + "preserves CPython code-member identity in public Evidence", + async ({ cli }) => { + const golden = pythonPycEqualityGolden; + const directory = await createTestTempDirectory("rea-pyc-code-equality-"); + const path = join(directory, "equality.pyc"); + await writeFile(path, Buffer.from(golden.pyc_base64, "base64")); + const result = await cli.run({ + arguments: ["inspect-python-pyc", path, "--json"], + }); + expect(result.exitCode, result.stderr).toBe(0); + const report = completePycEvidenceSchema.parse( + result.json, + ).normalized_result; + expect(report.artifact).toMatchObject({ path, sha256: golden.sha256 }); + expect(report.code_objects[0]?.consts).toEqual( + golden.cases.map((sample) => ({ + kind: "frozenset", + length: sample.members, + })), + ); + expect(report.code_objects).toHaveLength(golden.code_objects); + expect(report.coverage.status).toBe("complete"); + }, +); + const marshalUtf8 = (bytes: Buffer): Buffer => { const length = Buffer.alloc(4); length.writeUInt32LE(bytes.length); diff --git a/tests/fixtures/python-pyc-equality/golden.json b/tests/fixtures/python-pyc-equality/golden.json new file mode 100644 index 0000000000..f68887b300 --- /dev/null +++ b/tests/fixtures/python-pyc-equality/golden.json @@ -0,0 +1,40 @@ +{ + "producer": "CPython 3.12.14, marshal version 0", + "sha256": "79ba971c36cafc602506514a020bdd8bd56d09baaf1fba37c79ea8b620553427", + "pyc_base64": "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", + "cases": [ + { + "label": "qualified name is ignored", + "members": 1 + }, + { + "label": "stack size is ignored", + "members": 1 + }, + { + "label": "line table distinguishes members", + "members": 2 + }, + { + "label": "exception table distinguishes members", + "members": 2 + }, + { + "label": "first line distinguishes members", + "members": 2 + }, + { + "label": "bool and int constants stay distinct", + "members": 2 + }, + { + "label": "int and float constants stay distinct", + "members": 2 + }, + { + "label": "signed zero constants stay distinct", + "members": 2 + } + ], + "code_objects": 15 +} diff --git a/tests/fixtures/python-pyc-equality/golden.ts b/tests/fixtures/python-pyc-equality/golden.ts new file mode 100644 index 0000000000..2d49fd65d2 --- /dev/null +++ b/tests/fixtures/python-pyc-equality/golden.ts @@ -0,0 +1,20 @@ +import { readFileSync } from "node:fs"; +import { z } from "zod"; + +/** Recorded independently by produce.py; CI needs no matching Python install. */ +export const pythonPycEqualityGolden = z + .strictObject({ + producer: z.literal("CPython 3.12.14, marshal version 0"), + sha256: z.string().regex(/^[0-9a-f]{64}$/u), + pyc_base64: z.string(), + cases: z.array( + z.strictObject({ + label: z.string(), + members: z.union([z.literal(1), z.literal(2)]), + }), + ), + code_objects: z.int().positive(), + }) + .parse( + JSON.parse(readFileSync(new URL("./golden.json", import.meta.url), "utf8")), + ); diff --git a/tests/fixtures/python-pyc-equality/produce.py b/tests/fixtures/python-pyc-equality/produce.py new file mode 100644 index 0000000000..13c62bd1a2 --- /dev/null +++ b/tests/fixtures/python-pyc-equality/produce.py @@ -0,0 +1,87 @@ +"""Regenerate with CPython 3.12.14: python3 -I -S produce.py [--check]. + +Only compile, replace, serialize, and load inert code objects; never execute them. +Marshal v0 avoids reference sharing, so every retained member is a distinct object. +Two-member frozensets are framed before loading: constructing a Python frozenset +first would deduplicate the inputs and conceal the behavior being tested. +""" +import base64 +import hashlib +import importlib.util +import json +import marshal +import struct +import sys +from pathlib import Path + +if sys.implementation.name != "cpython" or sys.version_info[:3] != (3, 12, 14): + raise SystemExit("This recorded oracle requires CPython 3.12.14.") + +base = compile("def f(a, b):\n return a + b\n", "equality.py", "exec").co_consts[0] +handler = compile( + "def f(a, b):\n try: return a / b\n except ZeroDivisionError: return None\n", + "equality.py", + "exec", +).co_consts[0] +cases = [ + ("qualified name is ignored", base, base.replace(co_qualname="other.f")), + ("stack size is ignored", base, base.replace(co_stacksize=base.co_stacksize + 1)), + ("line table distinguishes members", base, base.replace(co_linetable=b"")), + ("exception table distinguishes members", handler, handler.replace(co_exceptiontable=b"")), + ( + "first line distinguishes members", + base, + base.replace(co_firstlineno=base.co_firstlineno + 1), + ), + ( + "bool and int constants stay distinct", + base.replace(co_consts=(True,)), + base.replace(co_consts=(1,)), + ), + ( + "int and float constants stay distinct", + base.replace(co_consts=(1,)), + base.replace(co_consts=(1.0,)), + ), + ( + "signed zero constants stay distinct", + base.replace(co_consts=(0.0,)), + base.replace(co_consts=(-0.0,)), + ), +] + + +def frozen_pair(left, right): + return b">" + struct.pack("