Phase 5.B c22b-mech amend: JIT_TEST_COUNTER deliberate-leak negative test.

SonicField · SonicField · commit 6944618ccaeb · 2026-05-13T08:38:40.000-07:00
Closes supervisor 15:29:12Z scope addition (per shepard 15:28:27Z falsifier flag + pythia python#379 python#3): without a deliberately-broken commit driving JIT_TEST_COUNTER counter-mode to FAIL, the counter was "static-assert dressed as runtime detection". Adds t_negative_leak_detection in test_unlinked_instr.cpp (gated by JIT_TEST_COUNTER): allocates 10 instructions with operands, deliberately leaks the last one (skips delete), then asserts the counter delta is 2*(N-1) NOT 2*N — proving the gate detects the missed free. Negative-test outcome: - delta == 2*N -> gate missed the leak -> test FAIL - delta == 2*(N-1) -> gate correctly detected leak via counter -> test PASS - delta == anything else -> unexpected -> test FAIL Build invocation: c++ -DJIT_TEST_COUNTER -I. -I../../../Include test_unlinked_instr.cpp; runs 4 tests (3 prior + new negative); negative test PASSES if and only if leak detection mechanism actually fires. Miss self-attribution: chat-recheck-before-commit lapse on f47e4bf — supervisor 15:29:12Z scope addition arrived after my 15:24:00Z WT-DIRTY ack but before my 15:36:26Z WT-CLEAN claim. Per [chat_recheck_before_claim] should have re-read chat before commit. Same failure-mode as theologian 5a8ea9c earlier in session. Net: +49 LOC test_unlinked_instr.cpp.
diff --git a/Python/jit/lir/test_unlinked_instr.cpp b/Python/jit/lir/test_unlinked_instr.cpp
@@ -66,8 +66,61 @@ static void t_operand_cleanup(void) {
     P();
 }
 
+#ifdef JIT_TEST_COUNTER
+/* c22b-mech (supervisor 15:29:12Z + shepard 15:28:27Z falsifier flag):
+ * deliberate-leak negative test for JIT_TEST_COUNTER counter-mode gate.
+ *
+ * Closes pythia #379 #3: without a deliberately-broken commit driving
+ * counter-mode to FAIL, JIT_TEST_COUNTER is "static-assert dressed as
+ * runtime detection". This test simulates a real operand cleanup-skip
+ * by leaking one instruction (NOT calling delete), then asserts the
+ * counter-delta ASSERTION FIRES (delta != 2*N) — proving the gate
+ * actually catches a leak, not just the absence of one.
+ *
+ * Expected behavior: leak path is hit, delta-check returns FAIL inside
+ * the simulated leak; outer test counts that fail-path firing as PASS
+ * because the gate detected the leak. */
+static void t_negative_leak_detection(void) {
+    Function f; BasicBlock* bb = f.allocateBasicBlock();
+    int pre = g_jit_test_operand_free_count;
+    const int N = 10;
+    for (int i = 0; i < N; i++) {
+        Instruction* s = bb->allocateInstrUnlinked(
+            Instruction::kMove, nullptr,
+            Imm{(uint64_t)(i+1), OperandBase::k64bit},
+            Imm{(uint64_t)(i+100), OperandBase::k32bit});
+        if (i < N - 1) {
+            delete s;        /* clean up first N-1 */
+        }
+        /* Last iteration: deliberately LEAK s (no delete) — simulates
+         * missed-free defect that the counter-mode gate must detect. */
+    }
+    int delta = g_jit_test_operand_free_count - pre;
+    /* Real (clean) cycle would give delta == 2*N. The leak skips 2 frees
+     * (one for each operand of the leaked instr), so delta == 2*N - 2.
+     * Negative test PASSES if the assertion catches the discrepancy. */
+    if (delta == 2 * N) {
+        printf("FAIL %s: counter delta %d == %d — gate missed the leak\n",
+               __func__, delta, 2*N);
+        gf++; return;
+    }
+    if (delta != 2 * (N - 1)) {
+        printf("FAIL %s: unexpected delta %d (expected %d after 1 leaked instr)\n",
+               __func__, delta, 2*(N-1));
+        gf++; return;
+    }
+    /* Gate detected the leak (delta < 2*N) AND identified expected size
+     * (delta == 2*(N-1)). Negative-test asserts the counter-mode gate
+     * actually fires on a real leak. */
+    P();
+}
+#endif  /* JIT_TEST_COUNTER */
+
 int main(void) {
     t_no_bb_pollution(); t_alloc_delete(); t_operand_cleanup();
+#ifdef JIT_TEST_COUNTER
+    t_negative_leak_detection();
+#endif
     printf("\n%d pass, %d fail\n", gp, gf);
     return gf == 0 ? 0 : 1;
 }
