fix: address Codex review round 2 on #27924

- run.ps1: read stdout async while reading stderr sync, instead of
  ReadToEnd()-ing both sequentially - a process writing enough to the
  stream read second to fill its pipe buffer before the first stream
  closes would deadlock forever, since nothing drains the second
  stream while blocked on the first. Reproduced locally with a test
  program that only writes to stderr (15s hang), fixed, reverified
  (completes immediately, no regression in the 4-test suite).
- run.ps1: use -cnotmatch instead of -notmatch for the expected-
  substring check - -notmatch is case-insensitive by default in
  PowerShell, making run.ps1 laxer than run.sh's case-sensitive `case`
  pattern match and able to miss a diagnostics-wording regression that
  only changes case. Reproduced (differently-cased substring wrongly
  "matched"), fixed, reverified (mismatched case now fails, exact case
  still passes, suite still 4/4).
- run.sh: guard `work=$(mktemp -d)` with `|| exit 1` - an unguarded
  failure left $work empty, so exe="$work/$name.exe" silently became
  "/name.exe" (filesystem root). Reproduced via WSL with TMPDIR
  pointed at a nonexistent directory: the script proceeded, tried to
  write test binaries to /gc_alloc.exe and /hello.exe, and the crash
  test even produced a false PASS (wrong-reason nonzero exit) masking
  the real failure. Fixed, reverified (script now exits 1 immediately
  instead of limping along with a bogus work dir).

All from Codex, #27924 pullrequestreview-4767856781.

Author: quaesitor-scientiam

thirdparty/tccbin_tests/run.ps1

@@ -66,13 +66,22 @@ foreach ($dir in (Get-TestDirs)) {
         # returned, for short-lived processes - both reproduced locally).
         # ReadToEnd() blocks until the stream closes (i.e. the process has
         # actually finished producing output), so there's no race.
+        #
+        # stdout and stderr are read one async + one sync (not both
+        # ReadToEnd()'d sequentially) to avoid deadlocking: a process that
+        # writes enough to the stream read second to fill its OS pipe
+        # buffer before the stream read first closes would block forever,
+        # since nothing drains the second stream while ReadToEnd() blocks
+        # on the first - reproduced locally with a test program that only
+        # writes to stderr.
         $psi = [System.Diagnostics.ProcessStartInfo]::new($exe)
         $psi.RedirectStandardOutput = $true
         $psi.RedirectStandardError = $true
         $psi.UseShellExecute = $false
         $proc = [System.Diagnostics.Process]::Start($psi)
-        $stdoutText = $proc.StandardOutput.ReadToEnd()
+        $stdoutTask = $proc.StandardOutput.ReadToEndAsync()
         $stderrText = $proc.StandardError.ReadToEnd()
+        $stdoutText = $stdoutTask.GetAwaiter().GetResult()
         $proc.WaitForExit()
         $code = $proc.ExitCode
         $out = $stdoutText + $stderrText
@@ -84,7 +93,11 @@ foreach ($dir in (Get-TestDirs)) {
         elseif ($code -ne [int]$expectExit) {
             $ok = $false
         }
-        if ($expectSubstr -ne "" -and $out -notmatch [regex]::Escape($expectSubstr)) {
+        # -notmatch is case-INSENSITIVE by default in PowerShell, which
+        # would make this laxer than run.sh's case-sensitive `case`
+        # pattern match and could miss a diagnostic-wording regression
+        # that only changes case. -cnotmatch forces case-sensitivity.
+        if ($expectSubstr -ne "" -and $out -cnotmatch [regex]::Escape($expectSubstr)) {
             $ok = $false
         }
 

thirdparty/tccbin_tests/run.sh

@@ -34,7 +34,7 @@ if [ -n "$platform" ] && [ -d "$here/platform/$platform" ]; then
     dirs+=("$here/platform/$platform")
 fi
 
-work=$(mktemp -d)
+work=$(mktemp -d) || exit 1
 trap 'rm -rf "$work"' EXIT
 
 passed=0