diff --git a/bridge/native/rea_lldb_tracer.py b/bridge/native/rea_lldb_tracer.py index 45b2893e8..b99123bf4 100644 --- a/bridge/native/rea_lldb_tracer.py +++ b/bridge/native/rea_lldb_tracer.py @@ -323,31 +323,46 @@ def _wanted(spec, symbol): return symbol.startswith("-[" if method_type == "instance" else "+[") -def _record(context, thread, index, sequence, location, remaining_bytes): +def _read_register(frame, name): + error = lldb.SBError() + value = frame.FindRegister(name) + if not value.IsValid(): + raise RuntimeError("LLDB breakpoint register %s is unavailable" % name) + number = value.GetValueAsUnsigned(error) + if error.Fail(): + raise RuntimeError( + "LLDB breakpoint register %s could not be read: %s" % (name, error) + ) + return number + + +def _record(context, thread, frame, index, sequence, location, remaining_bytes): target, process, config = context["target"], context["process"], context["config"] - frame = thread.GetFrameAtIndex(0) symbol = location["symbol"] or "" if not _wanted(config["breakpoints"][index], symbol): return None names = ARGUMENT_REGISTERS.get(config["architecture"], []) + objc_method = symbol.startswith("-[") or symbol.startswith("+[") + values = { + name: _read_register(frame, name) + for name in names[: max(config["argument_registers"], 2 if objc_method else 0)] + } registers = [ - {"name": name, "value": _hex(frame.FindRegister(name).GetValueAsUnsigned())} + {"name": name, "value": _hex(values[name])} for name in names[: config["argument_registers"]] ] receiver_class = None selector = None - if symbol.startswith("-[") or symbol.startswith("+["): + if objc_method: error = lldb.SBError() text = process.ReadCStringFromMemory( - frame.FindRegister(names[1]).GetValueAsUnsigned(), + values[names[1]], MAX_SELECTOR_BYTES, error, ) selector = text if error.Success() and text else None if symbol.startswith("-["): - receiver_class = _dynamic_class( - target, frame.FindRegister(names[0]).GetValueAsUnsigned() - ) + receiver_class = _dynamic_class(target, values[names[0]]) estimated_base = ( _estimated_json_size(location) + _estimated_json_size(receiver_class) @@ -370,79 +385,100 @@ def _record(context, thread, index, sequence, location, remaining_bytes): return record -def _handle_stop(context, events, other_stops): - """Record breakpoint hits of one stop; return an outcome when tracing must end.""" - process = context["process"] - for thread in process: - reason = thread.GetStopReason() - if reason == lldb.eStopReasonBreakpoint: - index = context["breakpoint_index"].get(thread.GetStopReasonDataAtIndex(0)) - if index is None: - continue - frame = thread.GetFrameAtIndex(0) - location = _location(frame.GetPCAddress(), context["target"]) - symbol = location["symbol"] or "" - if not _wanted(context["config"]["breakpoints"][index], symbol): - continue - frame_count = max( - 0, - min(thread.GetNumFrames() - 1, context["config"]["backtrace_frames"]), - ) - event_frame_count = 1 + frame_count - if not _can_retain_trace( - context["retained_trace_bytes"], - context["retained_frames"], - 0, - event_frame_count, - ): - return "resource-limit" +# One trace runs in each owned LLDB subprocess. Its callbacks execute at the +# breakpoint before LLDB resumes, unlike snapshots of later public stop events. +_TRACE_CONTEXT = None + + +def _handle_breakpoint(context, frame, index): + """Read one hit while LLDB's breakpoint callback owns the stopped frame.""" + if not frame.IsValid() or frame.GetPC() == lldb.LLDB_INVALID_ADDRESS: + raise RuntimeError("LLDB breakpoint callback did not supply a readable frame") + thread = frame.GetThread() + events = context["events"] + location = _location(frame.GetPCAddress(), context["target"]) + symbol = location["symbol"] or "" + if not _wanted(context["config"]["breakpoints"][index], symbol): + return None + frame_count = max( + 0, + min(thread.GetNumFrames() - 1, context["config"]["backtrace_frames"]), + ) + event_frame_count = 1 + frame_count + if not _can_retain_trace( + context["retained_trace_bytes"], + context["retained_frames"], + 0, + event_frame_count, + ): + return "resource-limit" + try: + remaining_bytes = MAX_TRACE_BYTES - context["retained_trace_bytes"] + record = _record( + context, thread, frame, index, len(events), location, remaining_bytes + ) + except ValueError: + return "resource-limit" + if record is not None: + if not _fits_trace_budget(record, remaining_bytes): + return "resource-limit" + record_bytes = len(json.dumps(record).encode("utf-8")) + if context["retained_trace_bytes"] + record_bytes > MAX_TRACE_BYTES: + return "resource-limit" + for depth in range(1, frame_count + 1): try: - remaining_bytes = MAX_TRACE_BYTES - context["retained_trace_bytes"] - record = _record( - context, thread, index, len(events), location, remaining_bytes + location = _location( + thread.GetFrameAtIndex(depth).GetPCAddress(), context["target"] ) except ValueError: return "resource-limit" - if record is not None: - if not _fits_trace_budget(record, remaining_bytes): - return "resource-limit" - record_bytes = len(json.dumps(record).encode("utf-8")) - if context["retained_trace_bytes"] + record_bytes > MAX_TRACE_BYTES: - return "resource-limit" - for depth in range(1, frame_count + 1): - try: - location = _location( - thread.GetFrameAtIndex(depth).GetPCAddress(), context["target"] - ) - except ValueError: - return "resource-limit" - if ( - _estimated_json_size(location) + record_bytes + 1 - > MAX_TRACE_BYTES - context["retained_trace_bytes"] - ): - return "resource-limit" - location_bytes = len(json.dumps(location).encode("utf-8")) - addition = location_bytes + (1 if record["backtrace"] else 0) - if ( - context["retained_trace_bytes"] - + record_bytes - + addition - > MAX_TRACE_BYTES - ): - return "resource-limit" - record["backtrace"].append(location) - record_bytes += addition - journal = context.get("observation_journal") - if journal is not None and not journal.append( - {"kind": "event", "event": record} - ): - return "resource-limit" - events.append(record) - context["retained_frames"] += event_frame_count - context["retained_trace_bytes"] += record_bytes - if len(events) >= context["config"]["max_events"]: - return "event-limit" - elif reason in (lldb.eStopReasonSignal, lldb.eStopReasonException): + if ( + _estimated_json_size(location) + record_bytes + 1 + > MAX_TRACE_BYTES - context["retained_trace_bytes"] + ): + return "resource-limit" + location_bytes = len(json.dumps(location).encode("utf-8")) + addition = location_bytes + (1 if record["backtrace"] else 0) + if ( + context["retained_trace_bytes"] + + record_bytes + + addition + > MAX_TRACE_BYTES + ): + return "resource-limit" + record["backtrace"].append(location) + record_bytes += addition + journal = context.get("observation_journal") + if journal is not None and not journal.append( + {"kind": "event", "event": record} + ): + return "resource-limit" + events.append(record) + context["retained_frames"] += event_frame_count + context["retained_trace_bytes"] += record_bytes + if len(events) >= context["config"]["max_events"]: + return "event-limit" + return None + + +def breakpoint_hit(frame, location, internal_dict): + """LLDB callback: capture before resuming, and stop on a limit or failure.""" + context = _TRACE_CONTEXT + if context is None or context["outcome"] is not None or context["failure"] is not None: + return True + try: + index = context["breakpoint_index"][location.GetBreakpoint().GetID()] + context["outcome"] = _handle_breakpoint(context, frame, index) + except Exception as error: + context["failure"] = "%s: %s" % (type(error).__name__, error) + return True + return context["outcome"] is not None + + +def _handle_stop(context, other_stops): + """Retain non-breakpoint stop observations; callbacks already capture hits.""" + for thread in context["process"]: + if thread.GetStopReason() in (lldb.eStopReasonSignal, lldb.eStopReasonException): stop_description = thread.GetStopDescription(256) journal = context.get("observation_journal") if journal is not None and not journal.append( @@ -510,7 +546,17 @@ def _wait_for_exit(listener, process, seconds): listener.WaitForEvent(1, event) +def _failed_launch_description(process): + if process.GetState() != lldb.eStateExited or process.GetExitStatus() != -1: + return None + description = process.GetExitDescription() + if isinstance(description, str) and description.lower().startswith(("attach failed", "launch failed")): + return description + return None + + def trace(debugger, config): + global _TRACE_CONTEXT debugger.SetAsync(True) # Stop at the symbol itself, where argument registers still hold the ABI # arguments, even when line tables would let LLDB skip the prologue. @@ -577,6 +623,11 @@ def trace(debugger, config): stdout.close() stderr.close() return {"status": "launch-error", "error": error.GetCString()} + launch_failure = _failed_launch_description(process) + if launch_failure is not None: + stdout.close(expected_exit=True) + stderr.close(expected_exit=True) + return {"status": "launch-error", "error": launch_failure} stdout.mark_launched() stderr.mark_launched() # Publish the PID before any post-launch file or module inspection. The @@ -650,6 +701,11 @@ def trace(debugger, config): "observation_journal": observation_journal, } events = [] + context.update({"events": events, "outcome": None, "failure": None}) + _TRACE_CONTEXT = context + for breakpoints in created: + for breakpoint in breakpoints: + breakpoint.SetScriptCallbackFunction("rea_lldb_tracer.breakpoint_hit") other_stops = [] outcome = None deadline = started + config["duration_ms"] / 1000 @@ -670,7 +726,9 @@ def trace(debugger, config): if state == lldb.eStateExited: outcome = "exited" elif state == lldb.eStateStopped and not lldb.SBProcess.GetRestartedFromEvent(event): - outcome = _handle_stop(context, events, other_stops) + if context["failure"] is not None: + raise RuntimeError(context["failure"]) + outcome = context["outcome"] or _handle_stop(context, other_stops) if outcome is None: process.Continue() pid = process.GetProcessID() @@ -685,6 +743,12 @@ def trace(debugger, config): process_exited = process.GetState() == lldb.eStateExited stdout.close(expected_exit=process_exited) stderr.close(expected_exit=process_exited) + # SBTarget.Launch may succeed before debugserver reports an asynchronous + # attach failure as an exited SBProcess. Its -1 status is not a target + # exit code; preserve the debugger's concrete launch denial. + launch_failure = _failed_launch_description(process) + if launch_failure is not None: + return {"status": "launch-error", "error": launch_failure} launch_identity_stable = ( module_path_before is not None and module_path_after == module_path_before @@ -733,6 +797,7 @@ def trace(debugger, config): } finally: + _TRACE_CONTEXT = None if observation_journal is not None: try: observation_journal.handle.close() diff --git a/bridge/process/ProcessRunTokenReader.swift b/bridge/process/ProcessRunTokenReader.swift index 1438f8157..21a2726fb 100644 --- a/bridge/process/ProcessRunTokenReader.swift +++ b/bridge/process/ProcessRunTokenReader.swift @@ -152,7 +152,14 @@ private func readRunToken(pid: Int32, pointerSize: Int) -> RunTokenObservation { } bytes = Array(bytes.prefix(size)) do { - return RunTokenObservation(pid: pid, state: "readable", run_id: try token(in: bytes, pointerSize: pointerSize), reason: nil) + let runId = try token(in: bytes, pointerSize: pointerSize) + // A complete empty environment is readable for an ordinary image. Apple + // platform images can expose the same layout after the kernel withholds + // their environment, so they remain explicitly unverified without a token. + if runId == nil && isPlatformBinary(pid: pid) { + return unavailable(pid: pid, reason: "platform_binary_environment_withheld") + } + return RunTokenObservation(pid: pid, state: "readable", run_id: runId, reason: nil) } catch RunTokenReadError.duplicateToken { return unavailable(pid: pid, reason: "duplicate_run_token") } catch RunTokenReadError.invalidTokenEncoding { @@ -259,9 +266,6 @@ func token(in bytes: [UInt8], pointerSize: Int = MemoryLayout. throw RunTokenReadError.ambiguousEnvironmentBoundary } let environmentEntries = trailingEntries[.. result.events.map((event) => ({ + breakpoint_index: event.breakpoint_index, symbol: event.symbol, file_address: event.file_address, selector: event.selector, @@ -159,8 +155,7 @@ const checkBounds = async (binary) => { binary, [ JSON.stringify({ - breakpoints: [{ kind: "function", name: "nanosleep" }], - arguments: ["--wait"], + breakpoints: [{ kind: "function", name: "rea_call_add" }], max_events: 2, duration_ms: 30_000, }), @@ -189,8 +184,9 @@ const checkBounds = async (binary) => { }; const cliFailure = async (binary) => { + let output; try { - await exec( + const completed = await exec( process.execPath, [ fileURLToPath(new URL("rea.mjs", import.meta.url)), @@ -204,10 +200,11 @@ const cliFailure = async (binary) => { timeout: CLI_TIMEOUT_MS, }, ); + output = completed.stdout; } catch (cause) { return JSON.parse(cause.stdout); } - throw new Error("observe-native-calls unexpectedly succeeded"); + throw new Error(`observe-native-calls unexpectedly succeeded: ${output}`); }; /** Hardened runtime blocks the debugger unless get-task-allow is granted. */ @@ -226,6 +223,22 @@ const checkHardenedRuntime = async (directory, binary) => { const denied = await cliFailure(blocked); assert.equal(denied.code, "capability_unavailable"); assert.match(denied.details.reason, /^debugger-attach-denied: /u); + await withArtifactMcp(blocked, async (client) => { + const deniedMcp = await client.callTool( + { + name: "observe_native_calls", + arguments: INPUT, + }, + { timeout: CLI_TIMEOUT_MS }, + ); + assert.equal(deniedMcp.isError, true, JSON.stringify(deniedMcp)); + assert.equal(deniedMcp.structuredContent.error.code, denied.code); + assert.match( + deniedMcp.structuredContent.error.details.reason, + /^debugger-attach-denied: /u, + ); + assert.ok(deniedMcp.structuredContent.error.details.partial_observation); + }); const allowed = join(directory, "debuggable"); const entitlements = join(directory, "get-task-allow.plist"); await writeFile( @@ -267,14 +280,55 @@ try { "observe_native_calls", INPUT, ); + assert.equal( + viaMcp.process.outcome, + "exited", + JSON.stringify(viaMcp.coverage), + ); assert.deepEqual(stable(viaMcp), stable(viaCli)); assert.equal(viaMcp.process.stdout.text, viaCli.process.stdout.text); + + // Two caller selections may resolve to one address. Each must retain its + // own hit; consuming only the first stop-reason ID loses the second. + const overlapping = { + breakpoints: [ + { kind: "function", name: "rea_call_add" }, + { kind: "function", name: "rea_call_add", module: basename(binary) }, + ], + duration_ms: 30_000, + argument_registers: 2, + }; + const paired = await artifactMcpResult( + client, + "observe_native_calls", + overlapping, + ); + assert.equal(paired.process.outcome, "exited"); + assert.equal(paired.events.length, 6); + for (const index of [0, 1]) { + const hits = paired.events.filter( + (event) => event.breakpoint_index === index, + ); + assert.deepEqual( + hits.map((event) => event.registers[0].value), + ["0x0", "0x1", "0x2"], + ); + assert.ok(hits.every((event) => event.symbol === "rea_call_add")); + } + const capped = await artifactMcpResult(client, "observe_native_calls", { + ...overlapping, + max_events: 2, + }); + assert.equal(capped.process.outcome, "event-limit"); + assert.equal(capped.events.length, 2); + assert.equal(capped.process.terminated, true); }); await checkBounds(binary); await checkHardenedRuntime(directory, binary); console.log( JSON.stringify({ ok: true, + developer_mode: developerMode.stdout.trim(), mocked: false, cli: true, stdio_mcp: true, diff --git a/scripts/verify-native-ui.mjs b/scripts/verify-native-ui.mjs index 8e2f3e05e..174989b14 100644 --- a/scripts/verify-native-ui.mjs +++ b/scripts/verify-native-ui.mjs @@ -1,4 +1,5 @@ import { execFile, spawn } from "node:child_process"; +import assert from "node:assert/strict"; import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; @@ -7,6 +8,8 @@ import { promisify } from "node:util"; import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js"; import { observeNativeUi } from "../dist/native/NativeUiObservation.js"; import { NATIVE_UI_HELPER_MAX_BUFFER } from "../dist/native/NativeUiOutputBudget.js"; +import { artifactMcpResult, withArtifactMcp } from "./lib/artifact-e2e.mjs"; +import { observeProcessStartIdentity } from "../dist/process/ProcessOwnershipObservation.js"; if (process.platform !== "darwin") throw new Error( @@ -14,7 +17,9 @@ if (process.platform !== "darwin") ); const root = await mkdtemp(join(tmpdir(), "rea-ui-fixture-")); let child; +let childExit; let fixturePid; +let fixtureIdentity; let report; try { const childRetrievalTest = join(root, "child-retrieval-test"); @@ -89,6 +94,7 @@ try { ["-W", "-n", "-g", "--stdout", coordinates, join(root, "Fixture.app")], { stdio: "ignore" }, ); + childExit = new Promise((resolve) => child.once("exit", resolve)); let scope; const deadline = Date.now() + 20000; while (Date.now() < deadline) { @@ -104,6 +110,12 @@ try { "Source-owned UI fixture failed to expose one window within 20 seconds", ); fixturePid = scope.pid; + fixtureIdentity = await observeProcessStartIdentity(fixturePid); + assert.equal( + fixtureIdentity?.state, + "readable", + "Fixture OS start identity is unavailable", + ); const target = await parseBinaryTarget(executable); if (!target.ok) throw target.error; const observation = await observeNativeUi(target.value, "observe_native_ui", { @@ -180,6 +192,43 @@ try { `Native UI CLI did not preserve the selected scenario: ${JSON.stringify(evidence.error ?? evidence.normalized_result?.steps?.map(({ outcome, reason }) => ({ outcome, reason })))}`, ); scenarioStatus = "selected-AX-button-action-and-CLI-parity-observed"; + await withArtifactMcp(executable, async (client) => { + const observed = await artifactMcpResult(client, "observe_native_ui", { + ...scope, + screenshot: false, + }); + if ( + !observed.initial.nodes.some( + (node) => + node.role === "AXButton" && + JSON.stringify(node.path) === JSON.stringify(button.path), + ) + ) + throw new Error("MCP omitted the selected fixture's actual AX button"); + const captured = await artifactMcpResult( + client, + "capture_native_ui_scenario", + { + ...scope, + screenshot: false, + steps: [ + { kind: "click", path: button.path }, + { kind: "wait", milliseconds: 200 }, + ], + }, + ); + if ( + captured.steps.length !== 2 || + captured.steps.some((step) => step.outcome !== "completed") || + !captured.steps + .at(-1) + ?.after?.nodes.some( + (node) => node.title === "REA fixture incremented", + ) + ) + throw new Error("MCP did not observe the selected fixture's AX action"); + }); + scenarioStatus = "selected-AX-button-action-and-CLI-MCP-parity-observed"; } const mismatch = await observeNativeUi( { ...target.value, sha256: "0".repeat(64) }, @@ -201,17 +250,24 @@ try { target_owned: true, }; } finally { - if (fixturePid !== undefined) { - try { - process.kill(fixturePid, "SIGTERM"); - } catch (error) { - if (error.code !== "ESRCH") throw error; + if (fixturePid !== undefined && fixtureIdentity?.state === "readable") { + const current = await observeProcessStartIdentity(fixturePid); + if (current !== undefined) { + assert.ok( + current.state === "readable" && + current.identity === fixtureIdentity.identity, + "Fixture PID identity changed; refusing to signal another process", + ); + try { + process.kill(fixturePid, "SIGTERM"); + } catch (cause) { + if (cause.code !== "ESRCH") throw cause; + } } } if (child !== undefined && child.exitCode === null) { - const exited = new Promise((resolve) => child.once("exit", resolve)); child.kill("SIGTERM"); - await exited; + await childExit; } await rm(root, { recursive: true, force: true }); } diff --git a/scripts/verify/firmware/analysis.mjs b/scripts/verify/firmware/analysis.mjs index f72a78b4a..7f234240b 100644 --- a/scripts/verify/firmware/analysis.mjs +++ b/scripts/verify/firmware/analysis.mjs @@ -36,6 +36,14 @@ for (const variable of ["REA_BINWALK_COMMAND", "REA_UNBLOB_COMMAND"]) { ); await access(path); } +try { + await exec("7z", ["i"], { timeout: 10_000 }); +} catch (cause) { + throw new Error( + "verify:firmware prerequisite unavailable: Unblob's gzip/USTAR fixture extraction requires 7z on PATH", + { cause }, + ); +} const fixtureRoot = resolve( process.env.REA_FIRMWARE_FIXTURE_ROOT ?? join(repository, "_reference/firmware-integration/generated"), diff --git a/src/process/ProcessOwnershipObservation.ts b/src/process/ProcessOwnershipObservation.ts index 723c1b27c..6dc460d97 100644 --- a/src/process/ProcessOwnershipObservation.ts +++ b/src/process/ProcessOwnershipObservation.ts @@ -1,4 +1,5 @@ import { readFile } from "node:fs/promises"; +import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js"; import { launcherIdentityFailure } from "./ProcessOwnershipIdentity.js"; import { descendantsOf, liveProcesses } from "./ProcessOwnershipProcessTree.js"; @@ -300,6 +301,22 @@ export const createSystemProcessOwnershipHost = ( platform, prepare: async (signal) => { await darwinTokens?.prepare(signal); + if (platform === "linux") { + try { + const processes = await listProcesses(signal); + if (!processes.some(({ pid }) => pid === process.pid)) + throw new Error("ps did not report REA's current process"); + } catch (cause: unknown) { + if (isExpectedAbort(cause, signal)) throw cause; + const reason = `Linux process ownership inspection requires a procps-compatible ps on REA's PATH before launching a child: ${errorMessage(cause)}`; + throw new AnalysisCapabilityUnavailableError( + "process-ownership", + "prepare_owned_process", + reason, + { cause, userMessage: reason }, + ); + } + } }, listProcesses, async environment(pid) { diff --git a/tests/boundary/process/darwinProcessRunTokenReader.test.ts b/tests/boundary/process/darwinProcessRunTokenReader.test.ts index 81fbf9997..8e2977f50 100644 --- a/tests/boundary/process/darwinProcessRunTokenReader.test.ts +++ b/tests/boundary/process/darwinProcessRunTokenReader.test.ts @@ -548,7 +548,6 @@ it.skipIf(!onDarwin)( clearedAppleVectorTokenFailsClosed: true, callerPfzBeforeTokenRead: true, emptyLaterArgumentRead: true, - emptyEnvironmentFailsClosed: true, emptyArgv0Read: true, emptyEnvironmentRecordsBeforeTokenFailClosed: true, duplicateTokenFailsClosed: true, @@ -677,7 +676,7 @@ it.skipIf(!onDarwin)( ); it.skipIf(!onDarwin)( - "reads owned tokens with empty later arguments across executable path padding", + "reads owned tokens across executable padding and distinguishes a real empty environment", async () => { const root = await mkdtemp(join(tmpdir(), "rea-process-token-padding-")); const host = createSystemProcessOwnershipHost("darwin"); @@ -699,6 +698,7 @@ it.skipIf(!onDarwin)( ), ); } + children.push(await startNodeChild({})); const processes = await host.listProcesses(); const entries = children.map(({ pid }) => { const entry = processes.find((process) => process.pid === pid); @@ -710,6 +710,7 @@ it.skipIf(!onDarwin)( expect(children.map(({ pid }) => observations?.get(pid))).toEqual([ { state: "readable", runId: "synthetic-padding-0" }, { state: "readable", runId: "synthetic-padding-1" }, + { state: "readable" }, ]); } finally { for (const { child } of children) await stopNodeChild(child); diff --git a/tests/conformance/native/ui.swift b/tests/conformance/native/ui.swift index 0ee842b49..1d399f00d 100644 --- a/tests/conformance/native/ui.swift +++ b/tests/conformance/native/ui.swift @@ -4,6 +4,7 @@ let app = NSApplication.shared app.setActivationPolicy(.accessory) let window = NSWindow(contentRect: NSRect(x: 120, y: 120, width: 360, height: 180), styleMask: [.titled, .closable], backing: .buffered, defer: false) window.title = "REA source-owned UI verification" +window.animationBehavior = .none final class FixtureController: NSObject { @objc func increment(_ sender: NSButton) { sender.title = "REA fixture incremented" } } @@ -13,7 +14,8 @@ button.title = "Increment REA fixture" button.target = controller button.action = #selector(FixtureController.increment(_:)) window.contentView?.addSubview(button) -window.orderFront(nil) +window.makeKeyAndOrderFront(nil) +app.activate(ignoringOtherApps: true) DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { let record = "{\"pid\":\(ProcessInfo.processInfo.processIdentifier),\"window_id\":\(window.windowNumber)}\n" FileHandle.standardOutput.write(Data(record.utf8)) diff --git a/tests/fixtures/processRunTokenParserProbe.swift b/tests/fixtures/processRunTokenParserProbe.swift index b7185d433..a753511f9 100644 --- a/tests/fixtures/processRunTokenParserProbe.swift +++ b/tests/fixtures/processRunTokenParserProbe.swift @@ -132,13 +132,6 @@ struct ProcessRunTokenParserProbe { } catch RunTokenReadError.duplicateToken { duplicateTokenFailsClosed = true } - let emptyEnvironmentFailsClosed: Bool - do { - _ = try token(in: fixture(arguments: ["/fixture/executable"], environment: [])) - emptyEnvironmentFailsClosed = false - } catch RunTokenReadError.environmentUnavailable { - emptyEnvironmentFailsClosed = true - } let missingAppleBoundaryFailsClosed: Bool do { _ = try token(in: fixture( @@ -158,7 +151,6 @@ struct ProcessRunTokenParserProbe { "alternatePaddingRead": alternatePadding == "alternate-padding-token", "truncatedArgvFailsClosed": truncatedArgvFailsClosed, "duplicateTokenFailsClosed": duplicateTokenFailsClosed, - "emptyEnvironmentFailsClosed": emptyEnvironmentFailsClosed, "missingAppleBoundaryFailsClosed": missingAppleBoundaryFailsClosed, "emptyArgv0Read": emptyArgv0Read == "empty-argv0-token", "finalAssignmentArgumentRead": finalAssignmentArgumentRead == "final-assignment-token",