replace FORTSH_BIN with SHELL_BIN across all shell scripts

Status	File	+	-
M	`suites/builtins/integration/run_integration_tests.sh`	5	5
M	`suites/builtins/integration/test_int_builtin_cross.sh`	2	2
M	`suites/builtins/integration/test_int_control_flow.sh`	2	2
M	`suites/builtins/integration/test_int_error_handling.sh`	2	2
M	`suites/builtins/integration/test_int_expansion.sh`	2	2
M	`suites/builtins/integration/test_int_function.sh`	2	2
M	`suites/builtins/integration/test_int_job_control.sh`	3	3
M	`suites/builtins/integration/test_int_pipeline.sh`	3	3
M	`suites/builtins/integration/test_int_redirection.sh`	2	2
M	`suites/builtins/integration/test_int_scope_env.sh`	2	2
M	`suites/builtins/integration/test_int_signal_trap.sh`	2	2
M	`suites/builtins/integration/test_int_subshell.sh`	2	2
M	`suites/builtins/run_builtin_tests.sh`	5	5
M	`suites/posix/posix_compliance_advanced.sh`	6	6
M	`suites/posix/posix_compliance_builtins.sh`	58	58
M	`suites/posix/posix_compliance_charclass.sh`	33	33
M	`suites/posix/posix_compliance_control.sh`	132	132
M	`suites/posix/posix_compliance_coverage.sh`	8	8
M	`suites/posix/posix_compliance_extended.sh`	6	6
M	`suites/posix/posix_compliance_filetest.sh`	124	124
M	`suites/posix/posix_compliance_gaps.sh`	7	7
M	`suites/posix/posix_compliance_heredoc.sh`	81	81
M	`suites/posix/posix_compliance_jobcontrol.sh`	8	8
M	`suites/posix/posix_compliance_options.sh`	133	133
M	`suites/posix/posix_compliance_printf.sh`	45	45
M	`suites/posix/posix_compliance_quoting.sh`	106	106
M	`suites/posix/posix_compliance_redirect.sh`	87	87
M	`suites/posix/posix_compliance_special.sh`	142	142
M	`suites/posix/posix_compliance_test.sh`	7	7
M	`suites/posix/posix_compliance_untested.sh`	8	8
M	`suites/posix/posix_gaps_arithmetic.sh`	6	6
M	`suites/posix/posix_gaps_builtins.sh`	7	7
M	`suites/posix/posix_gaps_charclass.sh`	5	5
M	`suites/posix/posix_gaps_control.sh`	6	6
M	`suites/posix/posix_gaps_heredoc.sh`	6	6
M	`suites/posix/posix_gaps_quoting.sh`	5	5
M	`suites/posix/posix_gaps_redirect.sh`	6	6
M	`suites/posix/posix_gaps_special.sh`	5	5
M	`suites/posix/run_posix_tests.sh`	7	7
M	`suites/test_harness.sh`	1	1

suites/builtins/integration/run_integration_tests.shmodified

  done
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at %s\n" "$FORTSH_BIN"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at %s\n" "$SHELL_BIN"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi

suites/builtins/integration/test_int_builtin_cross.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-builtin-cross]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtin-to-builtin interactions

suites/builtins/integration/test_int_control_flow.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-control-flow]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtins in loops, conditionals, and control flow

suites/builtins/integration/test_int_error_handling.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-error-handling]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: error handling with set -e, pipefail, and error propagation

suites/builtins/integration/test_int_expansion.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-expansion]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtins with parameter, arithmetic, and command substitution

suites/builtins/integration/test_int_function.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-function]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtins in/with functions

suites/builtins/integration/test_int_job_control.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-job-control]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: job control, background processes, wait, kill
  # Output order of concurrent background jobs is non-deterministic — sort to normalize
  TEST_NUM=$((TEST_NUM + 1))
  _jc_expected=$(run_with_timeout "$TEST_TIMEOUT" "$BASH_REF" -c 'echo a & echo b & wait; echo done' 2>&1 | sort)
 -_jc_actual=$(run_with_timeout "$TEST_TIMEOUT" "$FORTSH_BIN" -c 'echo a & echo b & wait; echo done' 2>&1 | sort)
 +_jc_actual=$(run_with_timeout "$TEST_TIMEOUT" "$SHELL_BIN" -c 'echo a & echo b & wait; echo done' 2>&1 | sort)
  if [ "$_jc_expected" = "$_jc_actual" ]; then pass "multiple background wait all"
  else fail "multiple background wait all" "$_jc_expected" "$_jc_actual"; fi
  compare_output "background dollar-bang" 'sleep 0.01 & [ -n "$!" ] && echo has_pid'

suites/builtins/integration/test_int_pipeline.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-pipeline]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtins interacting with pipelines
  # Filter out non-deterministic "Broken pipe" errors from comparison
  TEST_NUM=$((TEST_NUM + 1))
  _pp_expected=$(run_with_timeout "$TEST_TIMEOUT" "$BASH_REF" -c 'echo test | { export PVAR=pipe; echo $PVAR; }; echo ${PVAR:-unset}' 2>&1 | grep -v 'Broken pipe')
 -_pp_actual=$(run_with_timeout "$TEST_TIMEOUT" "$FORTSH_BIN" -c 'echo test | { export PVAR=pipe; echo $PVAR; }; echo ${PVAR:-unset}' 2>&1 | grep -v 'Broken pipe')
 +_pp_actual=$(run_with_timeout "$TEST_TIMEOUT" "$SHELL_BIN" -c 'echo test | { export PVAR=pipe; echo $PVAR; }; echo ${PVAR:-unset}' 2>&1 | grep -v 'Broken pipe')
  if [ "$_pp_expected" = "$_pp_actual" ]; then pass "export in pipeline segment"
  else fail "export in pipeline segment" "$_pp_expected" "$_pp_actual"; fi
  compare_output "cmd sub in pipeline" 'echo "$(echo hello)" | tr h H'

suites/builtins/integration/test_int_redirection.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-redirection]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtins with I/O redirections

suites/builtins/integration/test_int_scope_env.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-scope-env]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: variable scope, export, source, environment inheritance

suites/builtins/integration/test_int_signal_trap.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-signal-trap]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: traps and signal handling

suites/builtins/integration/test_int_subshell.shmodified

  #!/bin/sh
  TEST_PREFIX="[int-subshell]"
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
  . "$SCRIPT_DIR/../test_harness.sh"
  # Integration tests: builtins in subshells

suites/builtins/run_builtin_tests.shmodified

  done
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../../bin/fortsh}"
 -export FORTSH_BIN
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 +export SHELL_BIN
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at %s\n" "$FORTSH_BIN"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at %s\n" "$SHELL_BIN"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi

suites/posix/posix_compliance_advanced.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
      "$BASH_REF" -c "$command" 2>&1 | normalize_output > "$posix_file" || true
      # Run in fortsh
 -    "$FORTSH_BIN" -c "$command" 2>&1 | normalize_output > "$fortsh_file" || true
 +    "$SHELL_BIN" -c "$command" 2>&1 | normalize_output > "$fortsh_file" || true
      # Compare outputs
      if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
      "$BASH_REF" -c "$command" > /dev/null 2>&1
      posix_exit=$?
 -    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    "$SHELL_BIN" -c "$command" > /dev/null 2>&1
      fortsh_exit=$?
      if [ "$posix_exit" -eq "$fortsh_exit" ]; then

suites/posix/posix_compliance_builtins.shmodified

  # ==============================================================================
  # Configuration
 -FORTSH_BIN="${FORTSH_BIN:-./bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  VERBOSE="${VERBOSE:-0}"
  # Test identification
      section "P0-1: readonly Variable Enforcement"
      # Test 1: Cannot modify readonly variable
 -    output=$($FORTSH_BIN -c 'readonly VAR=test; VAR=other' 2>&1)
 +    output=$($SHELL_BIN -c 'readonly VAR=test; VAR=other' 2>&1)
      if echo "$output" | grep -q "readonly variable"; then
          pass "P0-1.1: Readonly violation produces error message"
      else
      fi
      # Test 2: Exit code is 1 for readonly violation (bash compatibility)
 -    $FORTSH_BIN -c 'readonly VAR=test; VAR=other' >/dev/null 2>&1
 +    $SHELL_BIN -c 'readonly VAR=test; VAR=other' >/dev/null 2>&1
      if [ $? -eq 1 ]; then
          pass "P0-1.2: Readonly violation returns exit code 1"
      else
      fi
      # Test 3: Command after readonly violation should not execute
 -    output=$($FORTSH_BIN -c 'readonly VAR=test; VAR=other; echo SHOULD_NOT_PRINT' 2>&1)
 +    output=$($SHELL_BIN -c 'readonly VAR=test; VAR=other; echo SHOULD_NOT_PRINT' 2>&1)
      if ! echo "$output" | grep -q "SHOULD_NOT_PRINT"; then
          pass "P0-1.3: Commands after readonly violation do not execute"
      else
      # Value preservation is implicitly tested by P0-1.1 (error occurs) and P0-1.3 (execution stops).
      # Test 5: Multiple readonly violations
 -    $FORTSH_BIN -c 'readonly A=1; readonly B=2; A=x; B=y' >/dev/null 2>&1
 +    $SHELL_BIN -c 'readonly A=1; readonly B=2; A=x; B=y' >/dev/null 2>&1
      if [ $? -eq 1 ]; then
          pass "P0-1.5: Multiple readonly violations handled correctly"
      else
      section "P0-2: set -u (nounset option)"
      # Test 1: Undefined variable in parameter expansion
 -    output=$($FORTSH_BIN -c 'set -u; echo ${UNDEFINED_VAR}' 2>&1)
 +    output=$($SHELL_BIN -c 'set -u; echo ${UNDEFINED_VAR}' 2>&1)
      if echo "$output" | grep -q "unbound variable"; then
          pass "P0-2.1: set -u detects undefined variable in \${VAR}"
      else
      fi
      # Test 2: Undefined variable in simple expansion
 -    output=$($FORTSH_BIN -c 'set -u; echo $UNDEFINED_SIMPLE' 2>&1)
 +    output=$($SHELL_BIN -c 'set -u; echo $UNDEFINED_SIMPLE' 2>&1)
      if echo "$output" | grep -q "unbound variable"; then
          pass "P0-2.2: set -u detects undefined variable in \$VAR"
      else
      # Test 3: Non-interactive shell exits on unbound variable
      # Bash uses exit code 127 for expansion errors (matching bash behavior)
 -    $FORTSH_BIN -c 'set -u; echo $UNDEF; echo SHOULD_NOT_PRINT' >/dev/null 2>&1
 +    $SHELL_BIN -c 'set -u; echo $UNDEF; echo SHOULD_NOT_PRINT' >/dev/null 2>&1
      exit_code=$?
 -    output=$($FORTSH_BIN -c 'set -u; echo $UNDEF; echo SHOULD_NOT_PRINT' 2>&1)
 +    output=$($SHELL_BIN -c 'set -u; echo $UNDEF; echo SHOULD_NOT_PRINT' 2>&1)
      if [ $exit_code -eq 127 ] && ! echo "$output" | grep -q "SHOULD_NOT_PRINT"; then
          pass "P0-2.3: Non-interactive shell exits on unbound variable"
      else
      fi
      # Test 4: Defined variable works with set -u
 -    output=$($FORTSH_BIN -c 'set -u; VAR=value; echo $VAR' 2>&1)
 +    output=$($SHELL_BIN -c 'set -u; VAR=value; echo $VAR' 2>&1)
      if echo "$output" | grep -q "value"; then
          pass "P0-2.4: Defined variables work correctly with set -u"
      else
      fi
      # Test 5: set +u disables the option
 -    output=$($FORTSH_BIN -c 'set -u; set +u; echo $UNDEFINED_AFTER_DISABLE' 2>&1)
 +    output=$($SHELL_BIN -c 'set -u; set +u; echo $UNDEFINED_AFTER_DISABLE' 2>&1)
      if ! echo "$output" | grep -q "unbound variable"; then
          pass "P0-2.5: set +u correctly disables nounset option"
      else
      fi
      # Test 6: Special variables always defined ($?, $$, etc.)
 -    output=$($FORTSH_BIN -c 'set -u; echo $? $$ $0' 2>&1)
 +    output=$($SHELL_BIN -c 'set -u; echo $? $$ $0' 2>&1)
      if ! echo "$output" | grep -q "unbound variable"; then
          pass "P0-2.6: Special variables don't trigger set -u"
      else
      section "P0-3: trap EXIT Execution"
      # Test 1: EXIT trap executes on exit builtin
 -    output=$($FORTSH_BIN -c 'trap "echo TRAPPED" EXIT; exit 0' 2>&1)
 +    output=$($SHELL_BIN -c 'trap "echo TRAPPED" EXIT; exit 0' 2>&1)
      if echo "$output" | grep -q "TRAPPED"; then
          pass "P0-3.1: EXIT trap executes on exit builtin"
      else
      fi
      # Test 2: EXIT trap preserves exit code
 -    $FORTSH_BIN -c 'trap "echo cleanup" EXIT; exit 42' >/dev/null 2>&1
 +    $SHELL_BIN -c 'trap "echo cleanup" EXIT; exit 42' >/dev/null 2>&1
      if [ $? -eq 42 ]; then
          pass "P0-3.2: EXIT trap preserves original exit code"
      else
      fi
      # Test 3: EXIT trap executes on natural shell exit
 -    output=$(echo 'trap "echo CLEANUP" EXIT; echo done' | $FORTSH_BIN 2>&1)
 +    output=$(echo 'trap "echo CLEANUP" EXIT; echo done' | $SHELL_BIN 2>&1)
      if echo "$output" | grep -q "CLEANUP"; then
          pass "P0-3.3: EXIT trap executes on natural shell termination"
      else
      fi
      # Test 4: EXIT trap executes only once
 -    output=$($FORTSH_BIN -c 'trap "echo ONCE" EXIT; exit 0' 2>&1)
 +    output=$($SHELL_BIN -c 'trap "echo ONCE" EXIT; exit 0' 2>&1)
      count=$(echo "$output" | grep -c "ONCE")
      if [ "$count" -eq 1 ]; then
          pass "P0-3.4: EXIT trap executes exactly once"
      fi
      # Test 5: EXIT trap can access variables
 -    output=$($FORTSH_BIN -c 'VAR=value; trap "echo \$VAR" EXIT; exit 0' 2>&1)
 +    output=$($SHELL_BIN -c 'VAR=value; trap "echo \$VAR" EXIT; exit 0' 2>&1)
      if echo "$output" | grep -q "value"; then
          pass "P0-3.5: EXIT trap can access shell variables"
      else
      fi
      # Test 6: EXIT trap with non-zero exit from command
 -    $FORTSH_BIN -c 'trap "echo cleanup" EXIT; false' >/dev/null 2>&1
 +    $SHELL_BIN -c 'trap "echo cleanup" EXIT; false' >/dev/null 2>&1
      if [ $? -eq 1 ]; then
          pass "P0-3.6: EXIT trap preserves command failure exit code"
      else
      # Test 1: Non-executable file returns 126
      touch /tmp/fortsh_test_nonexec
      chmod 644 /tmp/fortsh_test_nonexec
 -    $FORTSH_BIN -c '/tmp/fortsh_test_nonexec' >/dev/null 2>&1
 +    $SHELL_BIN -c '/tmp/fortsh_test_nonexec' >/dev/null 2>&1
      exit_code=$?
      rm -f /tmp/fortsh_test_nonexec
      fi
      # Test 2: Non-existent file still returns 127
 -    $FORTSH_BIN -c '/nonexistent/command/path' >/dev/null 2>&1
 +    $SHELL_BIN -c '/nonexistent/command/path' >/dev/null 2>&1
      if [ $? -eq 127 ]; then
          pass "P1-1.2: Non-existent command returns exit code 127"
      else
      echo '#!/bin/sh' > /tmp/fortsh_test_exec
      echo 'exit 5' >> /tmp/fortsh_test_exec
      chmod 755 /tmp/fortsh_test_exec
 -    $FORTSH_BIN -c '/tmp/fortsh_test_exec' >/dev/null 2>&1
 +    $SHELL_BIN -c '/tmp/fortsh_test_exec' >/dev/null 2>&1
      exit_code=$?
      rm -f /tmp/fortsh_test_exec
      # Test 1: set -C prevents overwriting existing files
      echo "original" > /tmp/fortsh_test_noclobber
 -    $FORTSH_BIN -c 'set -C; echo new > /tmp/fortsh_test_noclobber' >/dev/null 2>&1
 +    $SHELL_BIN -c 'set -C; echo new > /tmp/fortsh_test_noclobber' >/dev/null 2>&1
      exit_code=$?
      content=$(cat /tmp/fortsh_test_noclobber 2>/dev/null)
      rm -f /tmp/fortsh_test_noclobber
      # Test 2: set -C allows writing to new files
      rm -f /tmp/fortsh_test_noclobber_new
 -    $FORTSH_BIN -c 'set -C; echo content > /tmp/fortsh_test_noclobber_new' >/dev/null 2>&1
 +    $SHELL_BIN -c 'set -C; echo content > /tmp/fortsh_test_noclobber_new' >/dev/null 2>&1
      if [ -f /tmp/fortsh_test_noclobber_new ]; then
          pass "P1-2.2: set -C allows writing to non-existent files"
          rm -f /tmp/fortsh_test_noclobber_new
      # Test 3: >| forces overwrite even with noclobber
      echo "original" > /tmp/fortsh_test_force
 -    $FORTSH_BIN -c 'set -C; echo forced >| /tmp/fortsh_test_force' >/dev/null 2>&1
 +    $SHELL_BIN -c 'set -C; echo forced >| /tmp/fortsh_test_force' >/dev/null 2>&1
      content=$(cat /tmp/fortsh_test_force 2>/dev/null)
      rm -f /tmp/fortsh_test_force
      # Test 4: set +C disables noclobber
      echo "original" > /tmp/fortsh_test_disable
 -    $FORTSH_BIN -c 'set -C; set +C; echo new > /tmp/fortsh_test_disable' >/dev/null 2>&1
 +    $SHELL_BIN -c 'set -C; set +C; echo new > /tmp/fortsh_test_disable' >/dev/null 2>&1
      content=$(cat /tmp/fortsh_test_disable 2>/dev/null)
      rm -f /tmp/fortsh_test_disable
      section "P1-3: trap - SIGNAL (Trap Removal)"
      # Test 1: trap - INT removes INT trap
 -    output=$($FORTSH_BIN -c 'trap "echo caught" INT; trap - INT; kill -INT $$' 2>&1)
 +    output=$($SHELL_BIN -c 'trap "echo caught" INT; trap - INT; kill -INT $$' 2>&1)
      if ! echo "$output" | grep -q "caught"; then
          pass "P1-3.1: trap - INT removes INT trap"
      else
      fi
      # Test 2: trap - TERM removes TERM trap
 -    $FORTSH_BIN -c 'trap "echo term" TERM; trap - TERM; exit 0' >/dev/null 2>&1
 +    $SHELL_BIN -c 'trap "echo term" TERM; trap - TERM; exit 0' >/dev/null 2>&1
      if [ $? -eq 0 ]; then
          pass "P1-3.2: trap - TERM removes TERM trap"
      else
      fi
      # Test 3: trap - EXIT removes EXIT trap
 -    output=$($FORTSH_BIN -c 'trap "echo exit" EXIT; trap - EXIT; exit 0' 2>&1)
 +    output=$($SHELL_BIN -c 'trap "echo exit" EXIT; trap - EXIT; exit 0' 2>&1)
      if ! echo "$output" | grep -q "exit"; then
          pass "P1-3.3: trap - EXIT removes EXIT trap"
      else
      fi
      # Test 4: Listing traps after removal
 -    output=$($FORTSH_BIN -c 'trap "echo test" INT; trap - INT; trap' 2>&1)
 +    output=$($SHELL_BIN -c 'trap "echo test" INT; trap - INT; trap' 2>&1)
      if ! echo "$output" | grep -q "INT"; then
          pass "P1-3.4: Removed traps don't appear in trap listing"
      else
      section "P1-4: set -e in Conditional Contexts"
      # Test 1: set -e doesn't exit on false in if condition
 -    output=$($FORTSH_BIN -c 'set -e; if false; then echo no; else echo YES; fi' 2>&1)
 +    output=$($SHELL_BIN -c 'set -e; if false; then echo no; else echo YES; fi' 2>&1)
      if echo "$output" | grep -q "YES"; then
          pass "P1-4.1: set -e doesn't exit on false in if condition"
      else
      fi
      # Test 2: set -e doesn't exit on false in while condition
 -    output=$($FORTSH_BIN -c 'set -e; count=0; while false; do count=$((count+1)); done; echo AFTER' 2>&1)
 +    output=$($SHELL_BIN -c 'set -e; count=0; while false; do count=$((count+1)); done; echo AFTER' 2>&1)
      if echo "$output" | grep -q "AFTER"; then
          pass "P1-4.2: set -e doesn't exit on false in while condition"
      else
      fi
      # Test 3: set -e exits on command failure outside conditionals
 -    $FORTSH_BIN -c 'set -e; false; echo SHOULD_NOT_PRINT' >/dev/null 2>&1
 +    $SHELL_BIN -c 'set -e; false; echo SHOULD_NOT_PRINT' >/dev/null 2>&1
      exit_code=$?
      if [ $exit_code -ne 0 ]; then
          pass "P1-4.3: set -e exits on command failure outside conditionals"
      fi
      # Test 4: set -e with && and || operators
 -    output=$($FORTSH_BIN -c 'set -e; false || echo AFTER_OR' 2>&1)
 +    output=$($SHELL_BIN -c 'set -e; false || echo AFTER_OR' 2>&1)
      if echo "$output" | grep -q "AFTER_OR"; then
          pass "P1-4.4: set -e doesn't exit on false before ||"
      else
      fi
      # Test 5: set -e in until loop
 -    output=$($FORTSH_BIN -c 'set -e; count=0; until [ $count -eq 1 ]; do count=1; done; echo DONE' 2>&1)
 +    output=$($SHELL_BIN -c 'set -e; count=0; until [ $count -eq 1 ]; do count=1; done; echo DONE' 2>&1)
      if echo "$output" | grep -q "DONE"; then
          pass "P1-4.5: set -e doesn't exit on false in until condition"
      else
      section "P2-1: \$! (Background Process PID)"
      # Test 1: $! contains PID of last background job
 -    output=$($FORTSH_BIN -c 'sleep 0.1 & echo $!' 2>&1)
 +    output=$($SHELL_BIN -c 'sleep 0.1 & echo $!' 2>&1)
      if echo "$output" | grep -qE '^[0-9]+$'; then
          pass "P2-1.1: \$! expands to numeric PID"
      else
      fi
      # Test 2: $! updates after each background job
 -    output=$($FORTSH_BIN -c 'sleep 0.1 & pid1=$!; sleep 0.1 & pid2=$!; if [ "$pid1" != "$pid2" ]; then echo DIFFERENT; fi' 2>&1)
 +    output=$($SHELL_BIN -c 'sleep 0.1 & pid1=$!; sleep 0.1 & pid2=$!; if [ "$pid1" != "$pid2" ]; then echo DIFFERENT; fi' 2>&1)
      if echo "$output" | grep -q "DIFFERENT"; then
          pass "P2-1.2: \$! updates for each background job"
      else
      fi
      # Test 3: $! is empty/zero before any background jobs
 -    output=$($FORTSH_BIN -c 'echo "|$!|"' 2>&1)
 +    output=$($SHELL_BIN -c 'echo "|$!|"' 2>&1)
      if echo "$output" | grep -qE '\|[0-9]*\|'; then
          pass "P2-1.3: \$! has valid value before background jobs"
      else
      # Test 1: Source script with positional parameters
      echo 'echo "arg1=$1 arg2=$2"' > /tmp/fortsh_test_source
 -    output=$($FORTSH_BIN -c '. /tmp/fortsh_test_source hello world' 2>&1)
 +    output=$($SHELL_BIN -c '. /tmp/fortsh_test_source hello world' 2>&1)
      rm -f /tmp/fortsh_test_source
      if echo "$output" | grep -q "arg1=hello arg2=world"; then
      # Test 2: Source script preserves caller's variables
      echo 'SOURCED_VAR=from_script' > /tmp/fortsh_test_source2
 -    output=$($FORTSH_BIN -c '. /tmp/fortsh_test_source2; echo $SOURCED_VAR' 2>&1)
 +    output=$($SHELL_BIN -c '. /tmp/fortsh_test_source2; echo $SOURCED_VAR' 2>&1)
      rm -f /tmp/fortsh_test_source2
      if echo "$output" | grep -q "from_script"; then
      # Test 3: Source with absolute path
      echo 'echo sourced' > /tmp/fortsh_abs_source
 -    output=$($FORTSH_BIN -c '. /tmp/fortsh_abs_source' 2>&1)
 +    output=$($SHELL_BIN -c '. /tmp/fortsh_abs_source' 2>&1)
      rm -f /tmp/fortsh_abs_source
      if echo "$output" | grep -q "sourced"; then
      section "P2-3: Readonly Unset Prevention"
      # Test 1: Cannot unset readonly variable
 -    output=$($FORTSH_BIN -c 'readonly VAR=test; unset VAR' 2>&1)
 +    output=$($SHELL_BIN -c 'readonly VAR=test; unset VAR' 2>&1)
      if echo "$output" | grep -qE '(readonly|cannot unset)'; then
          pass "P2-3.1: unset readonly variable produces error"
      else
      fi
      # Test 2: Readonly variable still exists after unset attempt
 -    output=$($FORTSH_BIN -c 'readonly VAR=value; unset VAR 2>/dev/null; echo $VAR' 2>&1)
 +    output=$($SHELL_BIN -c 'readonly VAR=value; unset VAR 2>/dev/null; echo $VAR' 2>&1)
      if echo "$output" | grep -q "value"; then
          pass "P2-3.2: Readonly variable survives unset attempt"
      else
      fi
      # Test 3: unset returns non-zero for readonly variables
 -    $FORTSH_BIN -c 'readonly VAR=x; unset VAR' >/dev/null 2>&1
 +    $SHELL_BIN -c 'readonly VAR=x; unset VAR' >/dev/null 2>&1
      if [ $? -ne 0 ]; then
          pass "P2-3.3: unset readonly variable returns non-zero"
      else
      fi
      # Test 4: Can unset non-readonly variables
 -    output=$($FORTSH_BIN -c 'VAR=test; unset VAR; echo "|$VAR|"' 2>&1)
 +    output=$($SHELL_BIN -c 'VAR=test; unset VAR; echo "|$VAR|"' 2>&1)
      if echo "$output" | grep -q "||"; then
          pass "P2-3.4: unset works for non-readonly variables"
      else
      section "BONUS: Additional Builtin Tests"
      # Test shift builtin
 -    output=$($FORTSH_BIN -c 'set -- a b c; shift; echo $1' 2>&1)
 +    output=$($SHELL_BIN -c 'set -- a b c; shift; echo $1' 2>&1)
      if echo "$output" | grep -q "b"; then
          pass "BONUS-1: shift builtin works correctly"
      else
      fi
      # Test times builtin
 -    output=$($FORTSH_BIN -c 'times' 2>&1)
 +    output=$($SHELL_BIN -c 'times' 2>&1)
      if echo "$output" | grep -qE '[0-9]'; then
          pass "BONUS-2: times builtin produces output"
      else
      fi
      # Test hash builtin
 -    output=$($FORTSH_BIN -c 'hash' 2>&1)
 +    output=$($SHELL_BIN -c 'hash' 2>&1)
      if [ $? -eq 0 ]; then
          pass "BONUS-3: hash builtin executes without error"
      else
      fi
      # Test type builtin
 -    output=$($FORTSH_BIN -c 'type echo' 2>&1)
 +    output=$($SHELL_BIN -c 'type echo' 2>&1)
      if echo "$output" | grep -qiE '(builtin|command)'; then
          pass "BONUS-4: type builtin identifies commands"
      else
      fi
      # Test umask builtin
 -    output=$($FORTSH_BIN -c 'umask' 2>&1)
 +    output=$($SHELL_BIN -c 'umask' 2>&1)
      if echo "$output" | grep -qE '^[0-9]{4}$'; then
          pass "BONUS-5: umask builtin displays mask"
      else
      fi
      # Test getopts builtin
 -    output=$($FORTSH_BIN -c 'getopts "a:b" opt -a value; echo $opt' 2>&1)
 +    output=$($SHELL_BIN -c 'getopts "a:b" opt -a value; echo $opt' 2>&1)
      if echo "$output" | grep -q "a"; then
          pass "BONUS-6: getopts builtin parses options"
      else
      section "BONUS: Edge Cases"
      # Test empty command
 -    $FORTSH_BIN -c '' >/dev/null 2>&1
 +    $SHELL_BIN -c '' >/dev/null 2>&1
      if [ $? -eq 0 ]; then
          pass "EDGE-1: Empty command succeeds"
      else
      # Test semicolon alone
      # POSIX: Semicolon alone is a syntax error (exit code 2), not success
 -    $FORTSH_BIN -c ';' >/dev/null 2>&1
 +    $SHELL_BIN -c ';' >/dev/null 2>&1
      if [ $? -eq 2 ]; then
          pass "EDGE-2: Semicolon alone is syntax error"
      else
      fi
      # Test comment handling
 -    output=$($FORTSH_BIN -c 'echo visible # this is comment' 2>&1)
 +    output=$($SHELL_BIN -c 'echo visible # this is comment' 2>&1)
      if echo "$output" | grep -q "visible" && ! echo "$output" | grep -q "comment"; then
          pass "EDGE-3: Comments are ignored correctly"
      else
      fi
      # Test multiple semicolons
 -    output=$($FORTSH_BIN -c 'echo a;; echo b' 2>&1)
 +    output=$($SHELL_BIN -c 'echo a;; echo b' 2>&1)
      if echo "$output" | grep -q "b"; then
          pass "EDGE-4: Multiple semicolons handled"
      else
      echo "=========================================="
      echo "POSIX Compliance - Builtin Test Suite"
      echo "=========================================="
 -    echo "Testing: $FORTSH_BIN"
 +    echo "Testing: $SHELL_BIN"
      echo "Date: $(date)"
      echo ""
      # Verify fortsh exists
 -    if [ ! -x "$FORTSH_BIN" ]; then
 -        echo -e "${RED}ERROR: fortsh binary not found or not executable: $FORTSH_BIN${NC}"
 -        echo "Please build fortsh or set FORTSH_BIN environment variable"
 +    if [ ! -x "$SHELL_BIN" ]; then
 +        echo -e "${RED}ERROR: shell binary not found or not executable: $SHELL_BIN${NC}"
 +        echo "Please build fortsh or set SHELL_BIN environment variable"
          exit 1
      fi

suites/posix/posix_compliance_charclass.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "341. POSIX CHARACTER CLASS [:alpha:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alpha:]]*' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alpha:]]*' 2>&1)
  # Should match files starting with alphabetic characters
  if echo "$result" | grep -q "file1.txt\|FileA.txt"; then
      pass "[:alpha:] matches alphabetic characters"
      fail "[:alpha:] matches alphabetic characters" "files starting with letters" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && for f in [[:alpha:]]*.txt; do echo "$f"; done | head -1' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && for f in [[:alpha:]]*.txt; do echo "$f"; done | head -1' 2>&1)
  if [ -n "$result" ] && [ "$result" != '[[:alpha:]]*.txt' ]; then
      pass "[:alpha:] in loop context"
  else
  section "342. POSIX CHARACTER CLASS [:digit:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo data_[[:digit:]]*.csv' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo data_[[:digit:]]*.csv' 2>&1)
  if echo "$result" | grep -q "data_0"; then
      pass "[:digit:] matches numeric characters"
  else
      fail "[:digit:] matches numeric characters" "data_0*.csv files" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo *[[:digit:]][[:digit:]].csv' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo *[[:digit:]][[:digit:]].csv' 2>&1)
  if echo "$result" | grep -q "data_"; then
      pass "[:digit:][:digit:] matches two digits"
  else
  section "343. POSIX CHARACTER CLASS [:alnum:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alnum:]]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alnum:]]*.txt' 2>&1)
  if echo "$result" | grep -q "file"; then
      pass "[:alnum:] matches alphanumeric characters"
  else
  section "344. POSIX CHARACTER CLASS [:upper:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:upper:]]*.TXT' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:upper:]]*.TXT' 2>&1)
  if echo "$result" | grep -q "UPPER.TXT\|File"; then
      pass "[:upper:] matches uppercase characters"
  else
      fail "[:upper:] matches uppercase characters" "uppercase files" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:upper:]][[:upper:]][[:upper:]]*.TXT' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:upper:]][[:upper:]][[:upper:]]*.TXT' 2>&1)
  if echo "$result" | grep -q "UPPER.TXT\|ABC"; then
      pass "[:upper:] repeated matches multiple uppercase"
  else
  section "345. POSIX CHARACTER CLASS [:lower:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:lower:]]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:lower:]]*.txt' 2>&1)
  if echo "$result" | grep -q "file\|lower"; then
      pass "[:lower:] matches lowercase characters"
  else
  # =====================================
  # [:space:] in variable content
 -result=$("$FORTSH_BIN" -c 'x="hello world"; case "$x" in *[[:space:]]*) echo "has space";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello world"; case "$x" in *[[:space:]]*) echo "has space";; esac' 2>&1)
  if [ "$result" = "has space" ]; then
      pass "[:space:] matches space in case pattern"
  else
  # =====================================
  # [:blank:] matches space and tab only
 -result=$("$FORTSH_BIN" -c 'x="a	b"; case "$x" in *[[:blank:]]*) echo "has blank";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a	b"; case "$x" in *[[:blank:]]*) echo "has blank";; esac' 2>&1)
  if [ "$result" = "has blank" ]; then
      pass "[:blank:] matches tab character"
  else
  section "348. POSIX CHARACTER CLASS [:xdigit:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'case "a1b2c3" in [[:xdigit:]]*) echo "starts with hex";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "a1b2c3" in [[:xdigit:]]*) echo "starts with hex";; esac' 2>&1)
  if [ "$result" = "starts with hex" ]; then
      pass "[:xdigit:] matches hexadecimal digits"
  else
      fail "[:xdigit:] matches hexadecimal digits" "starts with hex" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'case "DEADBEEF" in [[:xdigit:]]*) echo "valid hex";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "DEADBEEF" in [[:xdigit:]]*) echo "valid hex";; esac' 2>&1)
  if [ "$result" = "valid hex" ]; then
      pass "[:xdigit:] matches uppercase hex"
  else
  section "349. POSIX CHARACTER CLASS [:punct:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'case "hello!" in *[[:punct:]]) echo "ends with punct";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "hello!" in *[[:punct:]]) echo "ends with punct";; esac' 2>&1)
  if [ "$result" = "ends with punct" ]; then
      pass "[:punct:] matches punctuation"
  else
      fail "[:punct:] matches punctuation" "ends with punct" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'case "@#$%" in [[:punct:]]*) echo "starts with punct";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "@#$%" in [[:punct:]]*) echo "starts with punct";; esac' 2>&1)
  if [ "$result" = "starts with punct" ]; then
      pass "[:punct:] matches special characters"
  else
  section "350. POSIX CHARACTER CLASS [:print:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'case "hello" in [[:print:]]*) echo "printable";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "hello" in [[:print:]]*) echo "printable";; esac' 2>&1)
  if [ "$result" = "printable" ]; then
      pass "[:print:] matches printable characters"
  else
  section "351. POSIX CHARACTER CLASS [:graph:]"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'case "abc123" in [[:graph:]]*) echo "graphical";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "abc123" in [[:graph:]]*) echo "graphical";; esac' 2>&1)
  if [ "$result" = "graphical" ]; then
      pass "[:graph:] matches graphical characters"
  else
  # =====================================
  # Note: POSIX uses [!...] for negation, [^...] is bash extension
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [!A-Z]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [!A-Z]*.txt' 2>&1)
  if echo "$result" | grep -q "file\|lower"; then
      pass "[!...] negation matches non-uppercase (POSIX standard)"
  else
      fail "[!...] negation matches non-uppercase (POSIX standard)" "lowercase files" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [!0-9]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [!0-9]*.txt' 2>&1)
  if echo "$result" | grep -q "file\|File"; then
      pass "[!...] negation matches non-digits"
  else
  section "353. POSIX RANGE EXPRESSIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo file[1-3].txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo file[1-3].txt' 2>&1)
  if echo "$result" | grep -q "file1.txt\|file2.txt\|file3.txt"; then
      pass "[1-3] range matches digits 1-3"
  else
      fail "[1-3] range matches digits 1-3" "file1-3.txt" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo File[A-C].txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo File[A-C].txt' 2>&1)
  if echo "$result" | grep -q "FileA.txt\|FileB.txt\|FileC.txt"; then
      pass "[A-C] range matches uppercase A-C"
  else
      fail "[A-C] range matches uppercase A-C" "FileA-C.txt" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [a-z]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [a-z]*.txt' 2>&1)
  if echo "$result" | grep -q "file\|lower"; then
      pass "[a-z] range matches lowercase"
  else
  section "354. COMBINED CHARACTER CLASSES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alpha:][:digit:]]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alpha:][:digit:]]*.txt' 2>&1)
  if echo "$result" | grep -q "file\|File"; then
      pass "[[:alpha:][:digit:]] combined classes"
  else
      fail "[[:alpha:][:digit:]] combined classes" "alphanumeric start" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'case "test123" in [[:alpha:]][[:alpha:]][[:alpha:]][[:alpha:]][[:digit:]][[:digit:]][[:digit:]]) echo "matched";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "test123" in [[:alpha:]][[:alpha:]][[:alpha:]][[:alpha:]][[:digit:]][[:digit:]][[:digit:]]) echo "matched";; esac' 2>&1)
  if [ "$result" = "matched" ]; then
      pass "Combined classes in exact pattern"
  else
  section "355. CHARACTER CLASS IN CASE STATEMENTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for word in hello WORLD 123 test!; do
      case "$word" in
          [[:upper:]]*) echo "$word: upper" ;;
  # =====================================
  # Literal hyphen at start
 -result=$("$FORTSH_BIN" -c 'case "-test" in [-a]*) echo "matched";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "-test" in [-a]*) echo "matched";; esac' 2>&1)
  if [ "$result" = "matched" ]; then
      pass "Literal hyphen at bracket start"
  else
  fi
  # Literal bracket
 -result=$("$FORTSH_BIN" -c 'case "[test]" in \[*) echo "matched";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "[test]" in \[*) echo "matched";; esac' 2>&1)
  if [ "$result" = "matched" ]; then
      pass "Escaped bracket in pattern"
  else
  fi
  # Empty class should not match
 -result=$("$FORTSH_BIN" -c 'case "test" in []) echo "empty";; *) echo "star";; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "test" in []) echo "empty";; *) echo "star";; esac' 2>&1)
  if [ "$result" = "star" ]; then
      pass "Empty bracket expression fallthrough"
  else
  section "357. CHARACTER CLASS WITH GLOB PATTERNS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo *[[:digit:]].*' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo *[[:digit:]].*' 2>&1)
  if echo "$result" | grep -q "data_0\|file"; then
      pass "Character class with glob wildcards"
  else
      fail "Character class with glob wildcards" "digit-containing files" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alpha:]]?[[:alpha:]]?[[:alpha:]]*.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alpha:]]?[[:alpha:]]?[[:alpha:]]*.txt' 2>&1)
  if echo "$result" | grep -q "file\|File\|lower"; then
      pass "Character class with ? wildcards"
  else

suites/posix/posix_compliance_control.shmodified

1041 lines changed — click to load

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "411. SUBSHELL EXECUTION ( )"
  # =====================================
 -result=$("$FORTSH_BIN" -c '(echo hello)' 2>&1)
 +result=$("$SHELL_BIN" -c '(echo hello)' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Basic subshell execution"
  else
      fail "Basic subshell execution" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=outer; (x=inner; echo $x); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=outer; (x=inner; echo $x); echo $x' 2>&1)
  expected=$(printf "inner\nouter")
  if [ "$result" = "$expected" ]; then
      pass "Subshell variable isolation"
      fail "Subshell variable isolation" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '(cd /tmp; pwd); pwd' 2>&1)
 +result=$("$SHELL_BIN" -c '(cd /tmp; pwd); pwd' 2>&1)
  # Should show /tmp then original dir
  if echo "$result" | head -1 | grep -q "/tmp"; then
      pass "Subshell cd isolation"
      fail "Subshell cd isolation" "/tmp then original" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '(exit 42); echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '(exit 42); echo $?' 2>&1)
  if [ "$result" = "42" ]; then
      pass "Subshell exit status propagation"
  else
      fail "Subshell exit status propagation" "42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '(echo a; echo b; echo c)' 2>&1)
 +result=$("$SHELL_BIN" -c '(echo a; echo b; echo c)' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "Subshell with multiple commands"
  section "412. BRACE GROUP { }"
  # =====================================
 -result=$("$FORTSH_BIN" -c '{ echo hello; }' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo hello; }' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Basic brace group"
  else
      fail "Basic brace group" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=outer; { x=inner; echo $x; }; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=outer; { x=inner; echo $x; }; echo $x' 2>&1)
  expected=$(printf "inner\ninner")
  if [ "$result" = "$expected" ]; then
      pass "Brace group shares variable scope"
      fail "Brace group shares variable scope" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '{ echo a; echo b; echo c; }' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo a; echo b; echo c; }' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "Brace group with multiple commands"
      fail "Brace group with multiple commands" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '{ false; }; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '{ false; }; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Brace group exit status"
  else
  section "413. BREAK WITH COUNT"
  # =====================================
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2 3; do
      for j in a b c; do
          if [ "$j" = "b" ]; then
      fail "break exits inner loop" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2 3; do
      for j in a b c; do
          if [ "$j" = "b" ]; then
      fail "break 2 exits both loops" "1a" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2 3; do
      break
      echo "not reached"
  section "414. CONTINUE WITH COUNT"
  # =====================================
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2 3; do
      if [ "$i" = "2" ]; then
          continue
      fail "continue skips iteration" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2; do
      for j in a b c; do
          if [ "$j" = "b" ]; then
  section "415. WHILE LOOP"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
  expected=$(printf "0\n1\n2")
  if [ "$result" = "$expected" ]; then
      pass "Basic while loop"
      fail "Basic while loop" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'while false; do echo no; done; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'while false; do echo no; done; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "While with false condition"
  else
      fail "While with false condition" "done" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  i=0
  while [ $i -lt 5 ]; do
      i=$((i+1))
  section "416. UNTIL LOOP"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
  expected=$(printf "0\n1\n2")
  if [ "$result" = "$expected" ]; then
      pass "Basic until loop"
      fail "Basic until loop" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'until true; do echo no; done; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'until true; do echo no; done; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "Until with true condition"
  else
  section "417. PIPELINE EXIT STATUS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'true | false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'true | false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Pipeline exit status is last command"
  else
      fail "Pipeline exit status is last command" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false | true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'false | true; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "Pipeline with false then true"
  else
      fail "Pipeline with false then true" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo hello | cat | cat; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello | cat | cat; echo $?' 2>&1)
  expected=$(printf "hello\n0")
  if [ "$result" = "$expected" ]; then
      pass "Multi-stage pipeline"
  section "418. AND-OR LISTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'true && echo yes' 2>&1)
 +result=$("$SHELL_BIN" -c 'true && echo yes' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "&& executes on success"
  else
      fail "&& executes on success" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false && echo yes; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'false && echo yes; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "&& skips on failure"
  else
      fail "&& skips on failure" "done" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false || echo fallback' 2>&1)
 +result=$("$SHELL_BIN" -c 'false || echo fallback' 2>&1)
  if [ "$result" = "fallback" ]; then
      pass "|| executes on failure"
  else
      fail "|| executes on failure" "fallback" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'true || echo no; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'true || echo no; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "|| skips on success"
  else
      fail "|| skips on success" "done" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'true && echo a && echo b' 2>&1)
 +result=$("$SHELL_BIN" -c 'true && echo a && echo b' 2>&1)
  expected=$(printf "a\nb")
  if [ "$result" = "$expected" ]; then
      pass "Chained && operators"
      fail "Chained && operators" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false || false || echo third' 2>&1)
 +result=$("$SHELL_BIN" -c 'false || false || echo third' 2>&1)
  if [ "$result" = "third" ]; then
      pass "Chained || operators"
  else
      fail "Chained || operators" "third" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false || true && echo mixed' 2>&1)
 +result=$("$SHELL_BIN" -c 'false || true && echo mixed' 2>&1)
  if [ "$result" = "mixed" ]; then
      pass "Mixed && and ||"
  else
  section "419. NEGATION WITH !"
  # =====================================
 -result=$("$FORTSH_BIN" -c '! false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '! false; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "! false returns 0"
  else
      fail "! false returns 0" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '! true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '! true; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "! true returns 1"
  else
      fail "! true returns 1" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '! echo hello >/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '! echo hello >/dev/null; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "! negates command exit status"
  else
  echo 'SOURCED_VAR=hello' > "$TEST_DIR/sourceme.sh"
  echo 'sourced_func() { echo "from func"; }' >> "$TEST_DIR/sourceme.sh"
 -result=$("$FORTSH_BIN" -c '. '"$TEST_DIR"'/sourceme.sh; echo $SOURCED_VAR' 2>&1)
 +result=$("$SHELL_BIN" -c '. '"$TEST_DIR"'/sourceme.sh; echo $SOURCED_VAR' 2>&1)
  if [ "$result" = "hello" ]; then
      pass ". sources file and sets variable"
  else
      fail ". sources file and sets variable" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '. '"$TEST_DIR"'/sourceme.sh; sourced_func' 2>&1)
 +result=$("$SHELL_BIN" -c '. '"$TEST_DIR"'/sourceme.sh; sourced_func' 2>&1)
  if echo "$result" | grep -q "from func"; then
      pass ". sources file and defines function"
  else
  # Test source with arguments
  echo 'echo "arg1=$1 arg2=$2"' > "$TEST_DIR/withargs.sh"
 -result=$("$FORTSH_BIN" -c '. '"$TEST_DIR"'/withargs.sh foo bar' 2>&1)
 +result=$("$SHELL_BIN" -c '. '"$TEST_DIR"'/withargs.sh foo bar' 2>&1)
  if [ "$result" = "arg1=foo arg2=bar" ]; then
      pass ". passes arguments to sourced script"
  else
  section "421. EXEC BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'exec echo replaced' 2>&1)
 +result=$("$SHELL_BIN" -c 'exec echo replaced' 2>&1)
  if [ "$result" = "replaced" ]; then
      pass "exec replaces shell with command"
  else
  fi
  # exec without command just does redirections
 -result=$("$FORTSH_BIN" -c 'exec 2>/dev/null; echo hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'exec 2>/dev/null; echo hello' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "exec without command continues shell"
  else
  section "422. EVAL BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cmd="echo hello"; eval $cmd' 2>&1)
 +result=$("$SHELL_BIN" -c 'cmd="echo hello"; eval $cmd' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "eval executes string as command"
  else
      fail "eval executes string as command" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=world; eval echo "hello $x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=world; eval echo "hello $x"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "eval with variable expansion"
  else
      fail "eval with variable expansion" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'eval "x=5; echo \$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'eval "x=5; echo \$x"' 2>&1)
  if [ "$result" = "5" ]; then
      pass "eval with multiple commands"
  else
      fail "eval with multiple commands" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'var=x; eval "$var=42"; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'var=x; eval "$var=42"; echo $x' 2>&1)
  if [ "$result" = "42" ]; then
      pass "eval for indirect assignment"
  else
  section "423. RETURN FROM FUNCTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'f() { return 0; echo no; }; f; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { return 0; echo no; }; f; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "return 0 from function"
  else
      fail "return 0 from function" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { return 42; }; f; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { return 42; }; f; echo $?' 2>&1)
  if [ "$result" = "42" ]; then
      pass "return with status code"
  else
      fail "return with status code" "42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { echo before; return; echo after; }; f' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo before; return; echo after; }; f' 2>&1)
  if [ "$result" = "before" ]; then
      pass "return without value"
  else
  section "424. FUNCTION LOCAL VARIABLES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=global; f() { local x=local; echo $x; }; f; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=global; f() { local x=local; echo $x; }; f; echo $x' 2>&1)
  expected=$(printf "local\nglobal")
  if [ "$result" = "$expected" ]; then
      pass "local variable in function"
      fail "local variable in function" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { local x=1; g() { echo $x; }; g; }; f' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { local x=1; g() { echo $x; }; g; }; f' 2>&1)
  if [ "$result" = "1" ]; then
      pass "local visible in nested function"
  else
      fail "local visible in nested function" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { local a=1 b=2; echo $a $b; }; f' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { local a=1 b=2; echo $a $b; }; f' 2>&1)
  if [ "$result" = "1 2" ]; then
      pass "local multiple variables"
  else
      fail "local multiple variables" "1 2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { local x; x=set; echo $x; }; f' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { local x; x=set; echo $x; }; f' 2>&1)
  if [ "$result" = "set" ]; then
      pass "local without initial value"
  else
  section "425. FUNCTION RECURSION"
  # =====================================
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  factorial() {
      if [ $1 -le 1 ]; then
          echo 1
      fail "Recursive function (factorial)" "120" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  count=0
  recurse() {
      count=$((count + 1))
  section "426. FUNCTION ARGUMENTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'f() { echo $1 $2 $3; }; f a b c' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo $1 $2 $3; }; f a b c' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "Function positional parameters"
  else
      fail "Function positional parameters" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { echo $#; }; f a b c d e' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo $#; }; f a b c d e' 2>&1)
  if [ "$result" = "5" ]; then
      pass "Function \$# count"
  else
      fail "Function \$# count" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { echo "$@"; }; f "a b" c' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo "$@"; }; f "a b" c' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "Function \$@ expansion"
  else
      fail "Function \$@ expansion" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { shift; echo $1; }; f a b c' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { shift; echo $1; }; f a b c' 2>&1)
  if [ "$result" = "b" ]; then
      pass "shift in function"
  else
      fail "shift in function" "b" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { set -- x y z; echo $1; }; f a b; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { set -- x y z; echo $1; }; f a b; echo done' 2>&1)
  expected=$(printf "x\ndone")
  if [ "$result" = "$expected" ]; then
      pass "set -- in function is local"
  section "427. FUNCTION OVERRIDE"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'f() { echo first; }; f() { echo second; }; f' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo first; }; f() { echo second; }; f' 2>&1)
  if [ "$result" = "second" ]; then
      pass "Function redefinition"
  else
      fail "Function redefinition" "second" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { echo orig; }; g() { f; }; f() { echo new; }; g' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo orig; }; g() { f; }; f() { echo new; }; g' 2>&1)
  if [ "$result" = "new" ]; then
      pass "Function sees redefined function"
  else
  section "428. UNSET FUNCTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'f() { echo hi; }; unset -f f; f 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo hi; }; unset -f f; f 2>/dev/null; echo $?' 2>&1)
  if echo "$result" | grep -qE "127|1"; then
      pass "unset -f removes function"
  else
  section "429. COLON BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c ':; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c ':; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass ": returns 0"
  else
      fail ": returns 0" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c ': this is ignored; echo ok' 2>&1)
 +result=$("$SHELL_BIN" -c ': this is ignored; echo ok' 2>&1)
  if [ "$result" = "ok" ]; then
      pass ": ignores arguments"
  else
      fail ": ignores arguments" "ok" "$result"
  fi
 -result=$("$FORTSH_BIN" -c ': ${x:=default}; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c ': ${x:=default}; echo $x' 2>&1)
  if [ "$result" = "default" ]; then
      pass ": for side effects in expansion"
  else
  section "426. TRUE AND FALSE BUILTINS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'true; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "true returns 0"
  else
      fail "true returns 0" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "false returns 1"
  else
  section "427. EXIT BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'exit 0; echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'exit 0; echo no' 2>&1)
  if [ -z "$result" ]; then
      pass "exit 0 terminates immediately"
  else
      fail "exit 0 terminates immediately" "(empty)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'exit 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'exit 42' 2>&1)
  code=$?
  if [ $code -eq 42 ]; then
      pass "exit with specific code"
      fail "exit with specific code" "42" "$code"
  fi
 -result=$("$FORTSH_BIN" -c 'false; exit' 2>&1)
 +result=$("$SHELL_BIN" -c 'false; exit' 2>&1)
  code=$?
  if [ $code -eq 1 ]; then
      pass "exit without arg uses last status"
  # =====================================
  # Simple exact match
 -result=$("$FORTSH_BIN" -c 'case "hello" in hello) echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "hello" in hello) echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case exact match"
  else
  fi
  # Glob pattern match
 -result=$("$FORTSH_BIN" -c 'case "hello" in h*) echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "hello" in h*) echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case glob pattern"
  else
  fi
  # Question mark match
 -result=$("$FORTSH_BIN" -c 'case "cat" in c?t) echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "cat" in c?t) echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case ? pattern"
  else
  fi
  # Bracket pattern
 -result=$("$FORTSH_BIN" -c 'case "b" in [abc]) echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "b" in [abc]) echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case [abc] bracket pattern"
  else
  fi
  # Multiple patterns with |
 -result=$("$FORTSH_BIN" -c 'case "two" in one|two|three) echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "two" in one|two|three) echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case multiple patterns with |"
  else
  fi
  # Default pattern *
 -result=$("$FORTSH_BIN" -c 'case "xyz" in abc) echo no;; *) echo default;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "xyz" in abc) echo no;; *) echo default;; esac' 2>&1)
  if [ "$result" = "default" ]; then
      pass "case * default pattern"
  else
  fi
  # No match produces nothing
 -result=$("$FORTSH_BIN" -c 'case "x" in y) echo no;; z) echo also no;; esac; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "x" in y) echo no;; z) echo also no;; esac; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "case no match produces empty"
  else
  fi
  # Variable in word
 -result=$("$FORTSH_BIN" -c 'x=hello; case "$x" in hello) echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello; case "$x" in hello) echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case with variable in word"
  else
  fi
  # Variable in pattern
 -result=$("$FORTSH_BIN" -c 'pat="hel*"; case "hello" in $pat) echo yes;; *) echo no;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'pat="hel*"; case "hello" in $pat) echo yes;; *) echo no;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case with variable in pattern"
  else
  fi
  # Quoted pattern (literal)
 -result=$("$FORTSH_BIN" -c 'case "h*" in "h*") echo yes;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "h*" in "h*") echo yes;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "case quoted pattern is literal"
  else
  # =====================================
  # if inside for
 -result=$("$FORTSH_BIN" -c 'for i in 1 2 3; do if [ $i -eq 2 ]; then echo found; fi; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for i in 1 2 3; do if [ $i -eq 2 ]; then echo found; fi; done' 2>&1)
  if [ "$result" = "found" ]; then
      pass "if inside for loop"
  else
  fi
  # case inside while
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 3 ]; do case $i in 1) echo one;; esac; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 3 ]; do case $i in 1) echo one;; esac; i=$((i+1)); done' 2>&1)
  if [ "$result" = "one" ]; then
      pass "case inside while loop"
  else
  fi
  # for inside if
 -result=$("$FORTSH_BIN" -c 'if true; then for i in a b; do echo $i; done; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'if true; then for i in a b; do echo $i; done; fi' 2>&1)
  expected=$(printf "a\nb")
  if [ "$result" = "$expected" ]; then
      pass "for inside if"
  fi
  # Deeply nested
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1; do
      for j in 2; do
          for k in 3; do
  # =====================================
  # while with counter
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
  expected=$(printf "0\n1\n2")
  if [ "$result" = "$expected" ]; then
      pass "while loop with counter"
  fi
  # until loop
 -result=$("$FORTSH_BIN" -c 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
  expected=$(printf "0\n1\n2")
  if [ "$result" = "$expected" ]; then
      pass "until loop"
  fi
  # while with compound condition
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 5 ] && [ $i -ne 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 5 ] && [ $i -ne 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
  expected=$(printf "0\n1\n2")
  if [ "$result" = "$expected" ]; then
      pass "while with compound condition"
  fi
  # Empty while body (using :)
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 3 ]; do : ; i=$((i+1)); done; echo $i' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 3 ]; do : ; i=$((i+1)); done; echo $i' 2>&1)
  if [ "$result" = "3" ]; then
      pass "while with empty body (colon)"
  else
  # =====================================
  # break in while
 -result=$("$FORTSH_BIN" -c 'i=0; while true; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while true; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i' 2>&1)
  if [ "$result" = "3" ]; then
      pass "break in while loop"
  else
  fi
  # continue in for
 -result=$("$FORTSH_BIN" -c 'for i in 1 2 3 4 5; do [ $i -eq 3 ] && continue; echo $i; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for i in 1 2 3 4 5; do [ $i -eq 3 ] && continue; echo $i; done' 2>&1)
  expected=$(printf "1\n2\n4\n5")
  if [ "$result" = "$expected" ]; then
      pass "continue in for loop"
  fi
  # break N for nested loops
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2; do
      for j in a b; do
          echo "$i$j"
  fi
  # continue N for nested loops
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2; do
      for j in a b; do
          [ "$i$j" = "1a" ] && continue 2
  # =====================================
  # for without in (uses positional params)
 -result=$("$FORTSH_BIN" -c 'set -- a b c; for x; do echo $x; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; for x; do echo $x; done' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "for without 'in' uses \$@"
  # for with glob pattern
  # Create temp files for glob test
 -result=$("$FORTSH_BIN" -c 'cd /tmp && touch _testglob_a _testglob_b && for f in _testglob_*; do echo $f; done | wc -l && rm -f _testglob_*' 2>&1 | head -1)
 +result=$("$SHELL_BIN" -c 'cd /tmp && touch _testglob_a _testglob_b && for f in _testglob_*; do echo $f; done | wc -l && rm -f _testglob_*' 2>&1 | head -1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "for with glob expansion"
  else
  fi
  # for with command substitution
 -result=$("$FORTSH_BIN" -c 'for x in $(echo a b c); do echo $x; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for x in $(echo a b c); do echo $x; done' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "for with command substitution"
  fi
  # for with quoted string (single iteration)
 -result=$("$FORTSH_BIN" -c 'for x in "a b c"; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for x in "a b c"; do echo "[$x]"; done' 2>&1)
  if [ "$result" = "[a b c]" ]; then
      pass "for with quoted string (single iteration)"
  else
  # =====================================
  # while with pipeline
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done | wc -l' 2>&1)
  if [ "$result" -eq 3 ] 2>/dev/null; then
      pass "while loop with pipeline"
  else
  fi
  # while with command substitution condition
 -result=$("$FORTSH_BIN" -c 'X=yes; while [ "$X" = "yes" ]; do echo once; X=no; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=yes; while [ "$X" = "yes" ]; do echo once; X=no; done' 2>&1)
  if [ "$result" = "once" ]; then
      pass "while with variable condition"
  else
  fi
  # infinite while with break
 -result=$("$FORTSH_BIN" -c 'i=0; while true; do i=$((i+1)); [ $i -ge 5 ] && break; done; echo $i' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while true; do i=$((i+1)); [ $i -ge 5 ] && break; done; echo $i' 2>&1)
  if [ "$result" = "5" ]; then
      pass "infinite while with break"
  else
  # =====================================
  # until basic
 -result=$("$FORTSH_BIN" -c 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done' 2>&1)
  expected=$(printf "0\n1\n2")
  if [ "$result" = "$expected" ]; then
      pass "until loop basic"
  fi
  # until with break
 -result=$("$FORTSH_BIN" -c 'i=0; until false; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; until false; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i' 2>&1)
  if [ "$result" = "3" ]; then
      pass "until with break"
  else
  # =====================================
  # if with command
 -result=$("$FORTSH_BIN" -c 'if true; then echo yes; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'if true; then echo yes; fi' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "if with true command"
  else
  fi
  # if with test
 -result=$("$FORTSH_BIN" -c 'X=5; if [ $X -gt 3 ]; then echo big; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=5; if [ $X -gt 3 ]; then echo big; fi' 2>&1)
  if [ "$result" = "big" ]; then
      pass "if with test condition"
  else
  fi
  # if-else
 -result=$("$FORTSH_BIN" -c 'if false; then echo no; else echo yes; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'if false; then echo no; else echo yes; fi' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "if-else statement"
  else
  fi
  # if-elif-else
 -result=$("$FORTSH_BIN" -c 'X=2; if [ $X -eq 1 ]; then echo one; elif [ $X -eq 2 ]; then echo two; else echo other; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=2; if [ $X -eq 1 ]; then echo one; elif [ $X -eq 2 ]; then echo two; else echo other; fi' 2>&1)
  if [ "$result" = "two" ]; then
      pass "if-elif-else statement"
  else
  fi
  # nested if
 -result=$("$FORTSH_BIN" -c 'X=1; Y=2; if [ $X -eq 1 ]; then if [ $Y -eq 2 ]; then echo both; fi; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=1; Y=2; if [ $X -eq 1 ]; then if [ $Y -eq 2 ]; then echo both; fi; fi' 2>&1)
  if [ "$result" = "both" ]; then
      pass "nested if statement"
  else
  # =====================================
  # case with character class
 -result=$("$FORTSH_BIN" -c 'x=5; case $x in [0-9]) echo digit;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; case $x in [0-9]) echo digit;; esac' 2>&1)
  if [ "$result" = "digit" ]; then
      pass "case with character class"
  else
  fi
  # case with negation
 -result=$("$FORTSH_BIN" -c 'x=x; case $x in [!0-9]) echo not_digit;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=x; case $x in [!0-9]) echo not_digit;; esac' 2>&1)
  if [ "$result" = "not_digit" ]; then
      pass "case with negation"
  else
  fi
  # case with question mark
 -result=$("$FORTSH_BIN" -c 'x=ab; case $x in ??) echo two_chars;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=ab; case $x in ??) echo two_chars;; esac' 2>&1)
  if [ "$result" = "two_chars" ]; then
      pass "case with question mark pattern"
  else
  fi
  # case fall-through (first match wins)
 -result=$("$FORTSH_BIN" -c 'x=a; case $x in a) echo first;; a) echo second;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=a; case $x in a) echo first;; a) echo second;; esac' 2>&1)
  if [ "$result" = "first" ]; then
      pass "case first match wins"
  else
  # =====================================
  # brace group in pipeline
 -result=$("$FORTSH_BIN" -c '{ echo a; echo b; } | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo a; echo b; } | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "brace group in pipeline"
  else
  fi
  # brace group with redirection
 -result=$("$FORTSH_BIN" -c '{ echo test; } > /tmp/brace_test_$$; cat /tmp/brace_test_$$; rm /tmp/brace_test_$$' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo test; } > /tmp/brace_test_$$; cat /tmp/brace_test_$$; rm /tmp/brace_test_$$' 2>&1)
  if [ "$result" = "test" ]; then
      pass "brace group with redirection"
  else
  fi
  # brace group preserves variables
 -result=$("$FORTSH_BIN" -c 'X=1; { X=2; }; echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=1; { X=2; }; echo $X' 2>&1)
  if [ "$result" = "2" ]; then
      pass "brace group preserves variable changes"
  else
  # =====================================
  # subshell in pipeline
 -result=$("$FORTSH_BIN" -c '(echo a; echo b) | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '(echo a; echo b) | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "subshell in pipeline"
  else
  fi
  # subshell isolates variables
 -result=$("$FORTSH_BIN" -c 'X=1; (X=2); echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=1; (X=2); echo $X' 2>&1)
  if [ "$result" = "1" ]; then
      pass "subshell isolates variable changes"
  else
  # Note: (( )) is arithmetic syntax in bash, not nested subshell
  # Both bash and fortsh correctly treat this as arithmetic and error
 -"$FORTSH_BIN" -c '((echo deep))' >/dev/null 2>&1
 +"$SHELL_BIN" -c '((echo deep))' >/dev/null 2>&1
  fortsh_exit=$?
  "$BASH_REF" -c '((echo deep))' >/dev/null 2>&1
  bash_exit=$?
  # =====================================
  # semicolon separated
 -result=$("$FORTSH_BIN" -c 'echo a; echo b; echo c' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo a; echo b; echo c' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "semicolon separated commands"
  fi
  # newline separated
 -result=$("$FORTSH_BIN" -c 'echo a
 +result=$("$SHELL_BIN" -c 'echo a
  echo b
  echo c' 2>&1)
  expected=$(printf "a\nb\nc")
  # =====================================
  # && chain
 -result=$("$FORTSH_BIN" -c 'true && true && echo success' 2>&1)
 +result=$("$SHELL_BIN" -c 'true && true && echo success' 2>&1)
  if [ "$result" = "success" ]; then
      pass "&& chain all true"
  else
  fi
  # && short-circuit
 -result=$("$FORTSH_BIN" -c 'false && echo never' 2>&1)
 +result=$("$SHELL_BIN" -c 'false && echo never' 2>&1)
  if [ -z "$result" ]; then
      pass "&& short-circuits on false"
  else
  fi
  # || chain
 -result=$("$FORTSH_BIN" -c 'false || false || echo fallback' 2>&1)
 +result=$("$SHELL_BIN" -c 'false || false || echo fallback' 2>&1)
  if [ "$result" = "fallback" ]; then
      pass "|| chain with fallback"
  else
  fi
  # || short-circuit
 -result=$("$FORTSH_BIN" -c 'true || echo never' 2>&1)
 +result=$("$SHELL_BIN" -c 'true || echo never' 2>&1)
  if [ -z "$result" ]; then
      pass "|| short-circuits on true"
  else
  fi
  # mixed && and ||
 -result=$("$FORTSH_BIN" -c 'false && echo no || echo yes' 2>&1)
 +result=$("$SHELL_BIN" -c 'false && echo no || echo yes' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "mixed && and ||"
  else
  # =====================================
  # ! negates exit status
 -result=$("$FORTSH_BIN" -c '! false && echo success' 2>&1)
 +result=$("$SHELL_BIN" -c '! false && echo success' 2>&1)
  if [ "$result" = "success" ]; then
      pass "! negates false to true"
  else
      fail "! negates false to true" "success" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '! true || echo failed' 2>&1)
 +result=$("$SHELL_BIN" -c '! true || echo failed' 2>&1)
  if [ "$result" = "failed" ]; then
      pass "! negates true to false"
  else
  fi
  # ! with pipeline
 -result=$("$FORTSH_BIN" -c '! echo test | grep -q nomatch && echo ok' 2>&1)
 +result=$("$SHELL_BIN" -c '! echo test | grep -q nomatch && echo ok' 2>&1)
  if [ "$result" = "ok" ]; then
      pass "! with pipeline"
  else
  # =====================================
  # function with return
 -result=$("$FORTSH_BIN" -c 'f() { return 42; }; f; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { return 42; }; f; echo $?' 2>&1)
  if [ "$result" = "42" ]; then
      pass "function with return value"
  else
  fi
  # function with arguments
 -result=$("$FORTSH_BIN" -c 'greet() { echo "Hello, $1"; }; greet World' 2>&1)
 +result=$("$SHELL_BIN" -c 'greet() { echo "Hello, $1"; }; greet World' 2>&1)
  if [ "$result" = "Hello, World" ]; then
      pass "function with arguments"
  else
  fi
  # function calling function
 -result=$("$FORTSH_BIN" -c 'a() { b; }; b() { echo called; }; a' 2>&1)
 +result=$("$SHELL_BIN" -c 'a() { b; }; b() { echo called; }; a' 2>&1)
  if [ "$result" = "called" ]; then
      pass "function calling function"
  else
  # =====================================
  # exit from subshell
 -result=$("$FORTSH_BIN" -c '(exit 7); echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '(exit 7); echo $?' 2>&1)
  if [ "$result" = "7" ]; then
      pass "exit from subshell"
  else
  fi
  # return from function
 -result=$("$FORTSH_BIN" -c 'f() { echo before; return; echo after; }; f' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo before; return; echo after; }; f' 2>&1)
  if [ "$result" = "before" ]; then
      pass "return stops function execution"
  else
  fi
  # return default value
 -result=$("$FORTSH_BIN" -c 'f() { true; return; }; f; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { true; return; }; f; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "return with no value uses last exit status"
  else

suites/posix/posix_compliance_coverage.shmodified

  # POSIX Compliance Coverage Tests - Filling Identified Gaps
  # These tests cover edge cases and behaviors not covered by other test suites
 -FORTSH_BIN="${FORTSH_BIN:-./bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Colors
      posix_output=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c "$test_cmd" 2>&1 | normalize_output)
      posix_exit=$?
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1 | normalize_output)
 +    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1 | normalize_output)
      fortsh_exit=$?
      if [ "$posix_output" = "$fortsh_output" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
      posix_output=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c "$test_cmd" 2>&1)
      posix_exit=$?
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      fortsh_exit=$?
      posix_norm=$(normalize_error "$posix_output")
      test_name="$1"
      test_cmd="$2"
 -    if FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +    if FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" >/dev/null 2>&1; then
          pass "$test_name"
      else
          fail "$test_name" "should succeed" "failed or not implemented"
      test_name="$1"
      test_cmd="$2"
 -    if ! FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +    if ! FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" >/dev/null 2>&1; then
          pass "$test_name"
      else
          fail "$test_name" "should fail" "succeeded unexpectedly"
      test_cmd="$2"
      expected_pattern="$3"
 -    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      if echo "$output" | grep -qE "$expected_pattern"; then
          pass "$test_name"
  # Pipeline timing can produce non-deterministic pipe errors — filter them out
  TEST_NUM=$((TEST_NUM + 1))
  _pf_expected=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c 'echo ok | false | cat; echo $?' 2>&1 | grep -v 'Broken pipe' | normalize_output)
 -_pf_actual=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c 'echo ok | false | cat; echo $?' 2>&1 | grep -v 'Broken pipe' | normalize_output)
 +_pf_actual=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c 'echo ok | false | cat; echo $?' 2>&1 | grep -v 'Broken pipe' | normalize_output)
  if [ "$_pf_expected" = "$_pf_actual" ]; then pass "pipeline with failures"
  else fail "pipeline with failures" "$_pf_expected" "$_pf_actual"; fi
      test_cmd="$2"
      expected_pattern="$3"
 -    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      if echo "$output" | grep -qiE "$expected_pattern"; then
          pass "$test_name"

suites/posix/posix_compliance_extended.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
      "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
      # Run in fortsh
 -    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
 +    "$SHELL_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
      # Compare outputs
      if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
      "$BASH_REF" -c "$command" > /dev/null 2>&1
      posix_exit=$?
 -    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    "$SHELL_BIN" -c "$command" > /dev/null 2>&1
      fortsh_exit=$?
      if [ "$posix_exit" -eq "$fortsh_exit" ]; then

suites/posix/posix_compliance_filetest.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "369. FILE EXISTENCE AND TYPE TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -e regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -e regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -e file ] exists test (regular file)"
  else
      fail "[ -e file ] exists test (regular file)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -e test_dir ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -e test_dir ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -e dir ] exists test (directory)"
  else
      fail "[ -e dir ] exists test (directory)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -e nonexistent ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -e nonexistent ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -e nonexistent ] returns false"
  else
      fail "[ -e nonexistent ] returns false" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -f regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -f regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -f file ] regular file test"
  else
      fail "[ -f file ] regular file test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -f test_dir ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -f test_dir ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -f dir ] returns false for directory"
  else
      fail "[ -f dir ] returns false for directory" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -d test_dir ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -d test_dir ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -d dir ] directory test"
  else
      fail "[ -d dir ] directory test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -d regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -d regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -d file ] returns false for file"
  else
  section "370. SYMBOLIC LINK TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -L symlink_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -L symlink_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -L symlink ] symbolic link test"
  else
      fail "[ -L symlink ] symbolic link test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -h symlink_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -h symlink_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -h symlink ] symbolic link test (alias)"
  else
      fail "[ -h symlink ] symbolic link test (alias)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -L regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -L regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -L regular ] returns false for non-symlink"
  else
      fail "[ -L regular ] returns false for non-symlink" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -L broken_link ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -L broken_link ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -L broken_link ] true for broken symlink"
  else
  section "371. FILE PERMISSION TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -r regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -r regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -r file ] readable test"
  else
      fail "[ -r file ] readable test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -w regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -w regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -w file ] writable test"
  else
      fail "[ -w file ] writable test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -x executable_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -x executable_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -x file ] executable test"
  else
      fail "[ -x file ] executable test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -x regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -x regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -x non-exec ] returns false"
  else
  section "372. FILE SIZE TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -s regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -s regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -s file ] size greater than zero"
  else
      fail "[ -s file ] size greater than zero" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -s empty_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -s empty_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -s empty ] returns false for empty file"
  else
  section "373. STRING TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ -z "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -z "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -z \"\" ] zero length string"
  else
      fail "[ -z \"\" ] zero length string" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -z "hello" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -z "hello" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -z str ] returns false for non-empty"
  else
      fail "[ -z str ] returns false for non-empty" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -n "hello" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -n "hello" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -n str ] non-zero length string"
  else
      fail "[ -n str ] non-zero length string" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -n "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -n "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -n \"\" ] returns false for empty"
  else
      fail "[ -n \"\" ] returns false for empty" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "hello" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "hello" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ string ] implicit non-empty test"
  else
      fail "[ string ] implicit non-empty test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ \"\" ] empty string is false"
  else
  section "374. STRING COMPARISON TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ "abc" = "abc" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "abc" = "abc" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ str = str ] string equality"
  else
      fail "[ str = str ] string equality" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "abc" = "xyz" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "abc" = "xyz" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ str1 = str2 ] returns false for different"
  else
      fail "[ str1 = str2 ] returns false for different" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "abc" != "xyz" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "abc" != "xyz" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ str1 != str2 ] string inequality"
  else
      fail "[ str1 != str2 ] string inequality" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "abc" != "abc" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "abc" != "abc" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ str != str ] returns false for same"
  else
  section "375. NUMERIC COMPARISON TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ 5 -eq 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -eq 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n -eq n ] numeric equality"
  else
      fail "[ n -eq n ] numeric equality" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -eq 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -eq 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ n1 -eq n2 ] returns false for different"
  else
      fail "[ n1 -eq n2 ] returns false for different" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -ne 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -ne 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n1 -ne n2 ] numeric inequality"
  else
      fail "[ n1 -ne n2 ] numeric inequality" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -gt 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -gt 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n1 -gt n2 ] greater than"
  else
      fail "[ n1 -gt n2 ] greater than" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 3 -gt 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 3 -gt 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ n1 -gt n2 ] returns false when not greater"
  else
      fail "[ n1 -gt n2 ] returns false when not greater" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -ge 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -ge 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n -ge n ] greater or equal (equal)"
  else
      fail "[ n -ge n ] greater or equal (equal)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -ge 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -ge 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n1 -ge n2 ] greater or equal (greater)"
  else
      fail "[ n1 -ge n2 ] greater or equal (greater)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 3 -lt 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 3 -lt 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n1 -lt n2 ] less than"
  else
      fail "[ n1 -lt n2 ] less than" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -lt 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -lt 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ n1 -lt n2 ] returns false when not less"
  else
      fail "[ n1 -lt n2 ] returns false when not less" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -le 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -le 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n -le n ] less or equal (equal)"
  else
      fail "[ n -le n ] less or equal (equal)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 3 -le 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 3 -le 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ n1 -le n2 ] less or equal (less)"
  else
  section "376. LOGICAL OPERATORS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ ! -e /nonexistent ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ ! -e /nonexistent ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ ! expr ] negation"
  else
      fail "[ ! expr ] negation" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ ! -d /tmp ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ ! -d /tmp ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ ! expr ] negation of true"
  else
      fail "[ ! expr ] negation of true" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -d /tmp -a -e /tmp ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -d /tmp -a -e /tmp ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ expr -a expr ] logical AND (both true)"
  else
      fail "[ expr -a expr ] logical AND (both true)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -d /tmp -a -e /nonexistent ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -d /tmp -a -e /nonexistent ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ expr -a expr ] logical AND (one false)"
  else
      fail "[ expr -a expr ] logical AND (one false)" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -e /nonexistent -o -d /tmp ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -e /nonexistent -o -d /tmp ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ expr -o expr ] logical OR (one true)"
  else
      fail "[ expr -o expr ] logical OR (one true)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -e /nonexistent -o -e /alsononexistent ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -e /nonexistent -o -e /alsononexistent ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ expr -o expr ] logical OR (both false)"
  else
  sleep 1
  touch "$TEST_DIR/newer_file"
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ newer_file -nt older_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ newer_file -nt older_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ f1 -nt f2 ] newer than test"
  else
      fail "[ f1 -nt f2 ] newer than test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ older_file -ot newer_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ older_file -ot newer_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ f1 -ot f2 ] older than test"
  else
      fail "[ f1 -ot f2 ] older than test" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ regular_file -ef regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ regular_file -ef regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ f -ef f ] same file test"
  else
  section "378. TEST COMMAND FORM"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'test -d /tmp && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'test -d /tmp && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test -d dir (test command form)"
  else
      fail "test -d dir (test command form)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test "hello" = "hello" && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'test "hello" = "hello" && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test str = str (test command form)"
  else
      fail "test str = str (test command form)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test 5 -gt 3 && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'test 5 -gt 3 && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test n1 -gt n2 (test command form)"
  else
  # Named pipe test (if created successfully)
  if [ -p "$TEST_DIR/named_pipe" ]; then
 -    result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -p named_pipe ] && echo yes || echo no' 2>&1)
 +    result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -p named_pipe ] && echo yes || echo no' 2>&1)
      if [ "$result" = "yes" ]; then
          pass "[ -p fifo ] named pipe test"
      else
      skip "[ -p fifo ] named pipe test" "mkfifo not available"
  fi
 -result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && [ -p regular_file ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd '"$TEST_DIR"' && [ -p regular_file ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -p regular ] returns false for non-pipe"
  else
  fi
  # Terminal test
 -result=$("$FORTSH_BIN" -c '[ -t 0 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -t 0 ] && echo yes || echo no' 2>&1)
  # Since we're running non-interactively, stdin is not a terminal
  if [ "$result" = "no" ]; then
      pass "[ -t 0 ] non-terminal stdin"
  section "380. EDGE CASES"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ ] empty test returns false"
  else
      fail "[ ] empty test returns false" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; [ -n "$x" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; [ -n "$x" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -n \"\$empty\" ] with empty variable"
  else
      fail "[ -n \"\$empty\" ] with empty variable" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="hello"; [ -n "$x" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello"; [ -n "$x" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -n \"\$var\" ] with non-empty variable"
  else
      fail "[ -n \"\$var\" ] with non-empty variable" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "=" = "=" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "=" = "=" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"=\" = \"=\" ] equals sign as string"
  else
      fail "[ \"=\" = \"=\" ] equals sign as string" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "-n" = "-n" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "-n" = "-n" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"-n\" = \"-n\" ] operator as string"
  else
  section "381. COMPLEX TEST EXPRESSIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ 1 -eq 1 -a 2 -eq 2 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 1 -eq 1 -a 2 -eq 2 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ a -a b ] both true"
  else
      fail "[ a -a b ] both true" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 1 -eq 1 -a 2 -eq 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 1 -eq 1 -a 2 -eq 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ a -a b ] second false"
  else
      fail "[ a -a b ] second false" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 1 -eq 2 -o 2 -eq 2 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 1 -eq 2 -o 2 -eq 2 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ a -o b ] second true"
  else
      fail "[ a -o b ] second true" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 1 -eq 2 -o 3 -eq 4 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 1 -eq 2 -o 3 -eq 4 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ a -o b ] both false"
  else
      fail "[ a -o b ] both false" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ ! 1 -eq 2 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ ! 1 -eq 2 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ ! expr ] negates false"
  else
      fail "[ ! expr ] negates false" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ ! 1 -eq 1 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ ! 1 -eq 1 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ ! expr ] negates true"
  else
  section "382. PARENTHESES IN TEST"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ \( 1 -eq 1 \) ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ \( 1 -eq 1 \) ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \\( expr \\) ] parentheses"
  else
      fail "[ \\( expr \\) ] parentheses" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ \( 1 -eq 1 -o 2 -eq 3 \) -a 3 -eq 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ \( 1 -eq 1 -o 2 -eq 3 \) -a 3 -eq 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \\( a -o b \\) -a c ] complex grouping"
  else
  section "383. STRING LENGTH COMPARISONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ -z "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -z "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -z \"\" ] empty string is zero length"
  else
      fail "[ -z \"\" ] empty string is zero length" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -z "x" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -z "x" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -z \"x\" ] non-empty has length"
  else
      fail "[ -z \"x\" ] non-empty has length" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -n "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -n "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -n \"\" ] empty has no length"
  else
      fail "[ -n \"\" ] empty has no length" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -n "abc" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -n "abc" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -n \"abc\" ] string has length"
  else
  section "384. NUMERIC EDGE CASES"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ 0 -eq 0 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 0 -eq 0 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 0 -eq 0 ] zero equals zero"
  else
      fail "[ 0 -eq 0 ] zero equals zero" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -5 -lt 0 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -5 -lt 0 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -5 -lt 0 ] negative less than zero"
  else
      fail "[ -5 -lt 0 ] negative less than zero" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -10 -gt -20 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -10 -gt -20 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -10 -gt -20 ] negative comparisons"
  else
      fail "[ -10 -gt -20 ] negative comparisons" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 999999 -gt 1 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 999999 -gt 1 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ large -gt 1 ] large numbers"
  else
  section "385. STRING VS NUMERIC"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ "10" = "10" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "10" = "10" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"10\" = \"10\" ] string comparison"
  else
      fail "[ \"10\" = \"10\" ] string comparison" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "10" = "010" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "10" = "010" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ \"10\" = \"010\" ] string differs from numeric"
  else
      fail "[ \"10\" = \"010\" ] string differs from numeric" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 10 -eq 010 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 10 -eq 010 ] && echo yes || echo no' 2>&1)
  # Numeric comparison - may or may not treat 010 as octal
  if [ "$result" = "yes" ] || [ "$result" = "no" ]; then
      pass "[ 10 -eq 010 ] numeric comparison"
  section "386. FILE TEST WITH VARIABLES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'f='"$TEST_DIR"'/regular_file; [ -f "$f" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'f='"$TEST_DIR"'/regular_file; [ -f "$f" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -f \"\$var\" ] variable as filename"
  else
      fail "[ -f \"\$var\" ] variable as filename" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'd='"$TEST_DIR"'; [ -d "$d" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'd='"$TEST_DIR"'; [ -d "$d" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -d \"\$var\" ] variable as dirname"
  else
  section "387. EMPTY OPERAND HANDLING"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'unset x; [ -n "$x" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; [ -n "$x" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -n \"\$unset\" ] unset variable"
  else
      fail "[ -n \"\$unset\" ] unset variable" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset x; [ -z "$x" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; [ -z "$x" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -z \"\$unset\" ] unset is zero length"
  else
      fail "[ -z \"\$unset\" ] unset is zero length" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset x; [ "$x" = "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; [ "$x" = "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"\$unset\" = \"\" ] unset equals empty"
  else
  section "388. NUMERIC COMPARISON OPERATORS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ 5 -eq 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -eq 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 5 -eq 5 ] equals"
  else
      fail "[ 5 -eq 5 ] equals" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -ne 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -ne 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 5 -ne 3 ] not equals"
  else
      fail "[ 5 -ne 3 ] not equals" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 10 -gt 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 10 -gt 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 10 -gt 5 ] greater than"
  else
      fail "[ 10 -gt 5 ] greater than" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 10 -ge 10 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 10 -ge 10 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 10 -ge 10 ] greater or equal"
  else
      fail "[ 10 -ge 10 ] greater or equal" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 3 -lt 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 3 -lt 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 3 -lt 5 ] less than"
  else
      fail "[ 3 -lt 5 ] less than" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 3 -le 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 3 -le 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 3 -le 3 ] less or equal"
  else
  section "389. NEGATIVE NUMBER TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ -5 -lt 0 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -5 -lt 0 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -5 -lt 0 ] negative less than zero"
  else
      fail "[ -5 -lt 0 ] negative less than zero" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -10 -lt -5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -10 -lt -5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -10 -lt -5 ] negative comparison"
  else
      fail "[ -10 -lt -5 ] negative comparison" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -5 -eq -5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -5 -eq -5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -5 -eq -5 ] negative equality"
  else
  section "390. STRING TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ "hello" = "hello" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "hello" = "hello" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"hello\" = \"hello\" ] string equality"
  else
      fail "[ \"hello\" = \"hello\" ] string equality" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "hello" != "world" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "hello" != "world" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"hello\" != \"world\" ] string inequality"
  else
      fail "[ \"hello\" != \"world\" ] string inequality" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "abc" \< "def" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "abc" \< "def" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"abc\" < \"def\" ] string less than"
  else
      fail "[ \"abc\" < \"def\" ] string less than" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "xyz" \> "abc" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "xyz" \> "abc" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"xyz\" > \"abc\" ] string greater than"
  else
  touch "$TEST_DIR/readable.txt"
  chmod 644 "$TEST_DIR/readable.txt"
 -result=$("$FORTSH_BIN" -c '[ -r "'"$TEST_DIR"'/readable.txt" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -r "'"$TEST_DIR"'/readable.txt" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -r file ] readable file"
  else
      fail "[ -r file ] readable file" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -w "'"$TEST_DIR"'/readable.txt" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -w "'"$TEST_DIR"'/readable.txt" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -w file ] writable file"
  else
  section "392. TEST BUILTIN vs [ COMMAND"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'test -f /etc/passwd && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'test -f /etc/passwd && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test -f /etc/passwd"
  else
      fail "test -f /etc/passwd" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test 5 -eq 5 && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'test 5 -eq 5 && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test 5 -eq 5"
  else
      fail "test 5 -eq 5" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test "hello" = "hello" && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c 'test "hello" = "hello" && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test string equality"
  else
  section "393. COMBINED LOGICAL TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ 5 -gt 3 ] && [ 10 -gt 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -gt 3 ] && [ 10 -gt 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ ] && [ ] both true"
  else
      fail "[ ] && [ ] both true" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 5 -lt 3 ] || [ 10 -gt 5 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 5 -lt 3 ] || [ 10 -gt 5 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ ] || [ ] one true"
  else
      fail "[ ] || [ ] one true" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '! [ 5 -lt 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '! [ 5 -lt 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "! [ ] negation"
  else
  section "394. FILE TYPE TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ -f /etc/passwd ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -f /etc/passwd ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -f /etc/passwd ] regular file"
  else
      fail "[ -f /etc/passwd ] regular file" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -d /tmp ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -d /tmp ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -d /tmp ] directory"
  else
      fail "[ -d /tmp ] directory" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -e /etc/passwd ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -e /etc/passwd ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -e /etc/passwd ] exists"
  else
      fail "[ -e /etc/passwd ] exists" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -e /nonexistent/path ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -e /nonexistent/path ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -e /nonexistent ] does not exist"
  else
  # =====================================
  echo "content" > "$TEST_DIR/nonempty.txt"
 -result=$("$FORTSH_BIN" -c '[ -s "'"$TEST_DIR"'/nonempty.txt" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -s "'"$TEST_DIR"'/nonempty.txt" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -s file ] non-empty file"
  else
  fi
  : > "$TEST_DIR/empty.txt"
 -result=$("$FORTSH_BIN" -c '[ -s "'"$TEST_DIR"'/empty.txt" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -s "'"$TEST_DIR"'/empty.txt" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -s file ] empty file is false"
  else
  # =====================================
  ln -sf /etc/passwd "$TEST_DIR/link_to_passwd" 2>/dev/null || true
 -result=$("$FORTSH_BIN" -c '[ -L "'"$TEST_DIR"'/link_to_passwd" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -L "'"$TEST_DIR"'/link_to_passwd" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -L symlink ] is symlink"
  else
      fail "[ -L symlink ] is symlink" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -h "'"$TEST_DIR"'/link_to_passwd" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -h "'"$TEST_DIR"'/link_to_passwd" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -h symlink ] is symlink (alternate)"
  else
  section "397. SPECIAL FILE TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ -c /dev/null ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -c /dev/null ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ -c /dev/null ] character device"
  else
      fail "[ -c /dev/null ] character device" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ -p /dev/null ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -p /dev/null ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ -p /dev/null ] not a pipe"
  else
  section "398. TERMINAL TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ -t 1 ] && echo tty || echo not_tty' 2>&1)
 +result=$("$SHELL_BIN" -c '[ -t 1 ] && echo tty || echo not_tty' 2>&1)
  # When running in a script, stdout is typically not a tty
  if echo "$result" | grep -qE "(tty|not_tty)"; then
      pass "[ -t 1 ] terminal test runs"
  section "399. COMPOUND EXPRESSION PRECEDENCE"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ 1 -eq 1 ] && [ 2 -eq 2 ] && [ 3 -eq 3 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 1 -eq 1 ] && [ 2 -eq 2 ] && [ 3 -eq 3 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "Multiple && chain"
  else
      fail "Multiple && chain" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 1 -eq 2 ] || [ 2 -eq 2 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 1 -eq 2 ] || [ 2 -eq 2 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "|| then && precedence"
  else
  section "400. EDGE CASE EXPRESSIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c '[ "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "no" ]; then
      pass "[ \"\" ] empty string is false"
  else
      fail "[ \"\" ] empty string is false" "no" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ "x" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ "x" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ \"x\" ] non-empty string is true"
  else
      fail "[ \"x\" ] non-empty string is true" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ 0 ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ 0 ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ 0 ] zero string is true (not numeric)"
  else
      fail "[ 0 ] zero string is true (not numeric)" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '[ ! "" ] && echo yes || echo no' 2>&1)
 +result=$("$SHELL_BIN" -c '[ ! "" ] && echo yes || echo no' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "[ ! \"\" ] negated empty is true"
  else

suites/posix/posix_compliance_gaps.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
      "$BASH_REF" -c "$command" 2>&1 | normalize_output > "$posix_file" || true
      # Run in fortsh
 -    "$FORTSH_BIN" -c "$command" 2>&1 | normalize_output > "$fortsh_file" || true
 +    "$SHELL_BIN" -c "$command" 2>&1 | normalize_output > "$fortsh_file" || true
      # Compare outputs
      if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
      "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
      # Run in fortsh
 -    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
 +    "$SHELL_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
      # Normalize error messages before comparison
      posix_norm=$(normalize_error "$(cat "$posix_file")")
      "$BASH_REF" -c "$command" > /dev/null 2>&1
      posix_exit=$?
 -    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    "$SHELL_BIN" -c "$command" > /dev/null 2>&1
      fortsh_exit=$?
      if [ "$posix_exit" -eq "$fortsh_exit" ]; then

suites/posix/posix_compliance_heredoc.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "396. BASIC HERE-DOCUMENT"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'cat <<EOF
 +result=$("$SHELL_BIN" -c 'cat <<EOF
  hello world
  EOF' 2>&1)
  if [ "$result" = "hello world" ]; then
      fail "Basic here-document" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cat <<END
 +result=$("$SHELL_BIN" -c 'cat <<END
  line one
  line two
  END' 2>&1)
      fail "Here-document multiple lines" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=world; cat <<EOF
 +result=$("$SHELL_BIN" -c 'x=world; cat <<EOF
  hello $x
  EOF' 2>&1)
  if [ "$result" = "hello world" ]; then
      fail "Here-document with variable expansion" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cat <<EOF
 +result=$("$SHELL_BIN" -c 'cat <<EOF
  result: $(echo test)
  EOF' 2>&1)
  if [ "$result" = "result: test" ]; then
  section "397. QUOTED HERE-DOCUMENT DELIMITER"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=world; cat <<"EOF"
 +result=$("$SHELL_BIN" -c 'x=world; cat <<"EOF"
  hello $x
  EOF' 2>&1)
  if [ "$result" = 'hello $x' ]; then
      fail "Quoted delimiter prevents expansion" 'hello $x' "$result"
  fi
 -result=$("$FORTSH_BIN" -c "cat <<'END'
 +result=$("$SHELL_BIN" -c "cat <<'END'
  test \$(echo foo)
  END" 2>&1)
  if [ "$result" = 'test $(echo foo)' ]; then
  section "398. HERE-DOCUMENT WITH TAB STRIPPING (<<-)"
  # =====================================
 -result=$("$FORTSH_BIN" -c '	cat <<-EOF
 +result=$("$SHELL_BIN" -c '	cat <<-EOF
  	hello
  	world
  	EOF' 2>&1)
      fail "<<- strips leading tabs" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cat <<-END
 +result=$("$SHELL_BIN" -c 'cat <<-END
  		indented
  	END' 2>&1)
  if [ "$result" = "indented" ]; then
  section "399. HERE-DOCUMENT TO DIFFERENT COMMANDS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'wc -l <<EOF
 +result=$("$SHELL_BIN" -c 'wc -l <<EOF
  one
  two
  three
          return $_to_rc
+     }
  fi
 -result=$(_timeout 2 "$FORTSH_BIN" -c 'read x <<EOF
 +result=$(_timeout 2 "$SHELL_BIN" -c 'read x <<EOF
  test input
  EOF
  echo "$x"' 2>&1)
  section "400. PARAMETER EXPANSION ${var:-default}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'unset x; echo ${x:-default}' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; echo ${x:-default}' 2>&1)
  if [ "$result" = "default" ]; then
      pass "\${var:-default} for unset variable"
  else
      fail "\${var:-default} for unset variable" "default" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo ${x:-default}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo ${x:-default}' 2>&1)
  if [ "$result" = "default" ]; then
      pass "\${var:-default} for empty variable"
  else
      fail "\${var:-default} for empty variable" "default" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=value; echo ${x:-default}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=value; echo ${x:-default}' 2>&1)
  if [ "$result" = "value" ]; then
      pass "\${var:-default} for set variable"
  else
      fail "\${var:-default} for set variable" "value" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset x; echo ${x-default}' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; echo ${x-default}' 2>&1)
  if [ "$result" = "default" ]; then
      pass "\${var-default} for unset (no colon)"
  else
      fail "\${var-default} for unset (no colon)" "default" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo ${x-default}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo ${x-default}' 2>&1)
  if [ "$result" = "" ]; then
      pass "\${var-default} for empty (no colon)"
  else
  section "401. PARAMETER EXPANSION ${var:+alternate}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=value; echo ${x:+alternate}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=value; echo ${x:+alternate}' 2>&1)
  if [ "$result" = "alternate" ]; then
      pass "\${var:+alternate} for set variable"
  else
      fail "\${var:+alternate} for set variable" "alternate" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset x; echo ${x:+alternate}' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; echo ${x:+alternate}' 2>&1)
  if [ "$result" = "" ]; then
      pass "\${var:+alternate} for unset variable"
  else
      fail "\${var:+alternate} for unset variable" "(empty)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo ${x:+alternate}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo ${x:+alternate}' 2>&1)
  if [ "$result" = "" ]; then
      pass "\${var:+alternate} for empty variable"
  else
  section "402. PARAMETER EXPANSION ${var:=assign}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'unset x; echo ${x:=assigned}; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; echo ${x:=assigned}; echo $x' 2>&1)
  expected=$(printf "assigned\nassigned")
  if [ "$result" = "$expected" ]; then
      pass "\${var:=value} assigns when unset"
      fail "\${var:=value} assigns when unset" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo ${x:=assigned}; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo ${x:=assigned}; echo $x' 2>&1)
  expected=$(printf "assigned\nassigned")
  if [ "$result" = "$expected" ]; then
      pass "\${var:=value} assigns when empty"
      fail "\${var:=value} assigns when empty" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=original; echo ${x:=assigned}; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=original; echo ${x:=assigned}; echo $x' 2>&1)
  expected=$(printf "original\noriginal")
  if [ "$result" = "$expected" ]; then
      pass "\${var:=value} keeps original when set"
  section "403. PARAMETER EXPANSION ${var:?error}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=value; echo ${x:?error message}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=value; echo ${x:?error message}' 2>&1)
  if [ "$result" = "value" ]; then
      pass "\${var:?error} returns value when set"
  else
      fail "\${var:?error} returns value when set" "value" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset x; echo ${x:?custom error}' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; echo ${x:?custom error}' 2>&1)
  if echo "$result" | grep -qi "error\|custom"; then
      pass "\${var:?error} shows error when unset"
  else
  section "404. PARAMETER EXPANSION ${#var}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=hello; echo ${#x}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello; echo ${#x}' 2>&1)
  if [ "$result" = "5" ]; then
      pass "\${#var} string length"
  else
      fail "\${#var} string length" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo ${#x}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo ${#x}' 2>&1)
  if [ "$result" = "0" ]; then
      pass "\${#var} empty string length"
  else
      fail "\${#var} empty string length" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="hello world"; echo ${#x}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello world"; echo ${#x}' 2>&1)
  if [ "$result" = "11" ]; then
      pass "\${#var} string with space"
  else
  section "405. PARAMETER EXPANSION ${var%pattern}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="file.txt"; echo ${x%.txt}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="file.txt"; echo ${x%.txt}' 2>&1)
  if [ "$result" = "file" ]; then
      pass "\${var%pattern} removes shortest suffix"
  else
      fail "\${var%pattern} removes shortest suffix" "file" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="file.tar.gz"; echo ${x%.*}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="file.tar.gz"; echo ${x%.*}' 2>&1)
  if [ "$result" = "file.tar" ]; then
      pass "\${var%.*} removes extension"
  else
      fail "\${var%.*} removes extension" "file.tar" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="file.tar.gz"; echo ${x%%.*}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="file.tar.gz"; echo ${x%%.*}' 2>&1)
  if [ "$result" = "file" ]; then
      pass "\${var%%.*} removes all extensions"
  else
  section "406. PARAMETER EXPANSION ${var#pattern}"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="/path/to/file"; echo ${x#*/}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="/path/to/file"; echo ${x#*/}' 2>&1)
  if [ "$result" = "path/to/file" ]; then
      pass "\${var#*/} removes shortest prefix"
  else
      fail "\${var#*/} removes shortest prefix" "path/to/file" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="/path/to/file"; echo ${x##*/}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="/path/to/file"; echo ${x##*/}' 2>&1)
  if [ "$result" = "file" ]; then
      pass "\${var##*/} basename extraction"
  else
      fail "\${var##*/} basename extraction" "file" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="prefix_name"; echo ${x#prefix_}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="prefix_name"; echo ${x#prefix_}' 2>&1)
  if [ "$result" = "name" ]; then
      pass "\${var#prefix} removes literal prefix"
  else
  section "407. BACKTICK COMMAND SUBSTITUTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo `echo hello`' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo `echo hello`' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Basic backtick substitution"
  else
      fail "Basic backtick substitution" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=`expr 2 + 3`; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=`expr 2 + 3`; echo $x' 2>&1)
  if [ "$result" = "5" ]; then
      pass "Backtick with expr"
  else
      fail "Backtick with expr" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo `echo \`echo nested\``' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo `echo \`echo nested\``' 2>&1)
  if [ "$result" = "nested" ]; then
      pass "Nested backtick substitution"
  else
  section "408. COMMAND SUBSTITUTION EDGE CASES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "$(echo "inner quotes")"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "$(echo "inner quotes")"' 2>&1)
  if [ "$result" = "inner quotes" ]; then
      pass "\$(...) with inner quotes"
  else
      fail "\$(...) with inner quotes" "inner quotes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $(echo $(echo nested))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(echo $(echo nested))' 2>&1)
  if [ "$result" = "nested" ]; then
      pass "Nested \$(...) substitution"
  else
      fail "Nested \$(...) substitution" "nested" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=$(cat <<EOF
 +result=$("$SHELL_BIN" -c 'x=$(cat <<EOF
  multi
  line
  EOF
  section "409. ARITHMETIC EXPANSION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo $((2 + 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((2 + 3))' 2>&1)
  if [ "$result" = "5" ]; then
      pass "\$((...)) addition"
  else
      fail "\$((...)) addition" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((10 - 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((10 - 3))' 2>&1)
  if [ "$result" = "7" ]; then
      pass "\$((...)) subtraction"
  else
      fail "\$((...)) subtraction" "7" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((4 * 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((4 * 5))' 2>&1)
  if [ "$result" = "20" ]; then
      pass "\$((...)) multiplication"
  else
      fail "\$((...)) multiplication" "20" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((20 / 4))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((20 / 4))' 2>&1)
  if [ "$result" = "5" ]; then
      pass "\$((...)) division"
  else
      fail "\$((...)) division" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((17 % 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((17 % 5))' 2>&1)
  if [ "$result" = "2" ]; then
      pass "\$((...)) modulo"
  else
      fail "\$((...)) modulo" "2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((x * 2))' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((x * 2))' 2>&1)
  if [ "$result" = "10" ]; then
      pass "\$((...)) with variable (no \$)"
  else
      fail "\$((...)) with variable (no \$)" "10" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $(($x * 2))' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $(($x * 2))' 2>&1)
  if [ "$result" = "10" ]; then
      pass "\$((...)) with \$variable"
  else
      fail "\$((...)) with \$variable" "10" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $(( (2 + 3) * 4 ))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(( (2 + 3) * 4 ))' 2>&1)
  if [ "$result" = "20" ]; then
      pass "\$((...)) with parentheses"
  else
      fail "\$((...)) with parentheses" "20" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((-5 + 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((-5 + 3))' 2>&1)
  if [ "$result" = "-2" ]; then
      pass "\$((...)) negative numbers"
  else
      fail "\$((...)) negative numbers" "-2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 > 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 > 3))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) greater than comparison"
  else
      fail "\$((...)) greater than comparison" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((3 > 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((3 > 5))' 2>&1)
  if [ "$result" = "0" ]; then
      pass "\$((...)) greater than false"
  else
      fail "\$((...)) greater than false" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 < 10))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 < 10))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) less than comparison"
  else
      fail "\$((...)) less than comparison" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 == 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 == 5))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) equality"
  else
      fail "\$((...)) equality" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 != 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 != 3))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) inequality"
  else
      fail "\$((...)) inequality" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 >= 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 >= 5))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) greater or equal"
  else
      fail "\$((...)) greater or equal" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((3 <= 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((3 <= 5))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) less or equal"
  else
      fail "\$((...)) less or equal" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((1 && 1))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((1 && 1))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) logical AND"
  else
      fail "\$((...)) logical AND" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((1 && 0))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((1 && 0))' 2>&1)
  if [ "$result" = "0" ]; then
      pass "\$((...)) logical AND false"
  else
      fail "\$((...)) logical AND false" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((0 || 1))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((0 || 1))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) logical OR"
  else
      fail "\$((...)) logical OR" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((!0))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((!0))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) logical NOT"
  else
      fail "\$((...)) logical NOT" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 & 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 & 3))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "\$((...)) bitwise AND"
  else
      fail "\$((...)) bitwise AND" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 | 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 | 3))' 2>&1)
  if [ "$result" = "7" ]; then
      pass "\$((...)) bitwise OR"
  else
      fail "\$((...)) bitwise OR" "7" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 ^ 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 ^ 3))' 2>&1)
  if [ "$result" = "6" ]; then
      pass "\$((...)) bitwise XOR"
  else
      fail "\$((...)) bitwise XOR" "6" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((1 << 4))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((1 << 4))' 2>&1)
  if [ "$result" = "16" ]; then
      pass "\$((...)) left shift"
  else
      fail "\$((...)) left shift" "16" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((16 >> 2))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((16 >> 2))' 2>&1)
  if [ "$result" = "4" ]; then
      pass "\$((...)) right shift"
  else
      fail "\$((...)) right shift" "4" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 > 3 ? 10 : 20))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 > 3 ? 10 : 20))' 2>&1)
  if [ "$result" = "10" ]; then
      pass "\$((...)) ternary true"
  else
      fail "\$((...)) ternary true" "10" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((5 < 3 ? 10 : 20))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 < 3 ? 10 : 20))' 2>&1)
  if [ "$result" = "20" ]; then
      pass "\$((...)) ternary false"
  else
      fail "\$((...)) ternary false" "20" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((x += 3)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((x += 3)); echo $x' 2>&1)
  expected=$(printf "8\n8")
  if [ "$result" = "$expected" ]; then
      pass "\$((...)) += assignment"
      fail "\$((...)) += assignment" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=10; echo $((x -= 3)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=10; echo $((x -= 3)); echo $x' 2>&1)
  expected=$(printf "7\n7")
  if [ "$result" = "$expected" ]; then
      pass "\$((...)) -= assignment"
      fail "\$((...)) -= assignment" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((x *= 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((x *= 3))' 2>&1)
  if [ "$result" = "15" ]; then
      pass "\$((...)) *= assignment"
  else
      fail "\$((...)) *= assignment" "15" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((++x)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((++x)); echo $x' 2>&1)
  expected=$(printf "6\n6")
  if [ "$result" = "$expected" ]; then
      pass "\$((...)) pre-increment"
      fail "\$((...)) pre-increment" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((x++)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((x++)); echo $x' 2>&1)
  expected=$(printf "5\n6")
  if [ "$result" = "$expected" ]; then
      pass "\$((...)) post-increment"
      fail "\$((...)) post-increment" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((--x)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((--x)); echo $x' 2>&1)
  expected=$(printf "4\n4")
  if [ "$result" = "$expected" ]; then
      pass "\$((...)) pre-decrement"
      fail "\$((...)) pre-decrement" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((x--)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((x--)); echo $x' 2>&1)
  expected=$(printf "5\n4")
  if [ "$result" = "$expected" ]; then
      pass "\$((...)) post-decrement"
      fail "\$((...)) post-decrement" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $(( 2 + 3 * 4 ))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(( 2 + 3 * 4 ))' 2>&1)
  if [ "$result" = "14" ]; then
      pass "\$((...)) operator precedence"
  else
      fail "\$((...)) operator precedence" "14" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'a=2; b=3; echo $(( a * b + a ))' 2>&1)
 +result=$("$SHELL_BIN" -c 'a=2; b=3; echo $(( a * b + a ))' 2>&1)
  if [ "$result" = "8" ]; then
      pass "\$((...)) multiple variables"
  else
  section "410. TILDE EXPANSION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo ~' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo ~' 2>&1)
  if [ "$result" = "$HOME" ]; then
      pass "~ expands to \$HOME"
  else
      fail "~ expands to \$HOME" "$HOME" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo ~/test' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo ~/test' 2>&1)
  if [ "$result" = "$HOME/test" ]; then
      pass "~/path expands correctly"
  else
      fail "~/path expands correctly" "$HOME/test" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=~; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=~; echo $x' 2>&1)
  if [ "$result" = "$HOME" ]; then
      pass "~ in assignment expands"
  else

suites/posix/posix_compliance_jobcontrol.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
      test_name="$1"
      test_cmd="$2"
 -    if FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +    if FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" >/dev/null 2>&1; then
          pass "$test_name"
      else
          fail "$test_name" "should succeed" "failed"
      test_cmd="$2"
      expected="$3"
 -    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      if [ "$output" = "$expected" ]; then
          pass "$test_name"
      else
      test_cmd="$2"
      pattern="$3"
 -    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      if echo "$output" | grep -q "$pattern"; then
          pass "$test_name"
      else
      test_cmd="$2"
      shift 2
 -    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      for word in "$@"; do
          if ! echo "$output" | grep -qF "$word"; then
              fail "$test_name" "output containing '$word'" "$output"

suites/posix/posix_compliance_options.shmodified

1047 lines changed — click to load

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "381. SET -e (ERREXIT)"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -e; true; echo reached' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -e; true; echo reached' 2>&1)
  if [ "$result" = "reached" ]; then
      pass "set -e allows true command"
  else
      fail "set -e allows true command" "reached" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -e; false; echo "should not reach"' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -e; false; echo "should not reach"' 2>&1)
  if [ -z "$result" ] || ! echo "$result" | grep -q "should not reach"; then
      pass "set -e exits on false"
  else
      fail "set -e exits on false" "(no output)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -e; if false; then echo no; fi; echo reached' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -e; if false; then echo no; fi; echo reached' 2>&1)
  if [ "$result" = "reached" ]; then
      pass "set -e ignores false in if condition"
  else
      fail "set -e ignores false in if condition" "reached" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -e; false || echo fallback' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -e; false || echo fallback' 2>&1)
  if [ "$result" = "fallback" ]; then
      pass "set -e ignores false with || continuation"
  else
      fail "set -e ignores false with || continuation" "fallback" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -e; ! false; echo reached' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -e; ! false; echo reached' 2>&1)
  if [ "$result" = "reached" ]; then
      pass "set -e ignores negated false"
  else
  section "382. SET -u (NOUNSET)"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -u; x=hello; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -u; x=hello; echo $x' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "set -u allows set variable"
  else
      fail "set -u allows set variable" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -u; echo $UNSET_VAR_12345' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -u; echo $UNSET_VAR_12345' 2>&1)
  exit_code=$?
  if echo "$result" | grep -qi "unbound\|unset\|error" || [ $exit_code -ne 0 ]; then
      pass "set -u errors on unset variable"
      fail "set -u errors on unset variable" "error message" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -u; echo ${UNSET_VAR_12345:-default}' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -u; echo ${UNSET_VAR_12345:-default}' 2>&1)
  if [ "$result" = "default" ]; then
      pass "set -u allows default expansion"
  else
  section "383. SET -f (NOGLOB)"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -f; echo *' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -f; echo *' 2>&1)
  if [ "$result" = "*" ]; then
      pass "set -f disables globbing"
  else
      fail "set -f disables globbing" "*" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -f; echo [a-z]*' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -f; echo [a-z]*' 2>&1)
  if [ "$result" = "[a-z]*" ]; then
      pass "set -f disables bracket patterns"
  else
      fail "set -f disables bracket patterns" "[a-z]*" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -f; set +f; cd /tmp && echo [a-z]* | head -c 20' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -f; set +f; cd /tmp && echo [a-z]* | head -c 20' 2>&1)
  if [ "$result" != "[a-z]*" ] && [ -n "$result" ]; then
      pass "set +f re-enables globbing"
  else
  section "384. SET -n (NOEXEC)"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -n; echo hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -n; echo hello' 2>&1)
  if [ -z "$result" ]; then
      pass "set -n prevents execution"
  else
  section "385. SET -x (XTRACE)"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -x; echo hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -x; echo hello' 2>&1)
  if echo "$result" | grep -q "echo hello\|+ echo"; then
      pass "set -x shows trace output"
  else
      fail "set -x shows trace output" "trace line" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -x; x=5; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -x; x=5; echo $x' 2>&1)
  if echo "$result" | grep -qE "x=5|echo 5|\+ echo"; then
      pass "set -x traces variable assignment"
  else
  # Note: set -v only echoes lines as they're READ, not from -c argument
  # Test that -v option is accepted and runs without error
 -"$FORTSH_BIN" -c 'set -v; echo hello' >/dev/null 2>&1
 +"$SHELL_BIN" -c 'set -v; echo hello' >/dev/null 2>&1
  fortsh_exit=$?
  "$BASH_REF" -c 'set -v; echo hello' >/dev/null 2>&1
  bash_exit=$?
  TEST_DIR="/tmp/fortsh_options_$$"
  mkdir -p "$TEST_DIR"
 -result=$("$FORTSH_BIN" -c 'set -C; echo test > '"$TEST_DIR"'/clobber1; echo test2 > '"$TEST_DIR"'/clobber1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -C; echo test > '"$TEST_DIR"'/clobber1; echo test2 > '"$TEST_DIR"'/clobber1' 2>&1)
  if echo "$result" | grep -qi "exist\|cannot\|error\|clobber"; then
      pass "set -C prevents clobbering existing file"
  else
  section "388. SET -o OPTIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -o errexit; true; echo ok' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -o errexit; true; echo ok' 2>&1)
  if [ "$result" = "ok" ]; then
      pass "set -o errexit (same as -e)"
  else
      fail "set -o errexit (same as -e)" "ok" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -o noglob; echo *' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -o noglob; echo *' 2>&1)
  if [ "$result" = "*" ]; then
      pass "set -o noglob (same as -f)"
  else
      fail "set -o noglob (same as -f)" "*" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -o nounset; x=val; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -o nounset; x=val; echo $x' 2>&1)
  if [ "$result" = "val" ]; then
      pass "set -o nounset (same as -u)"
  else
  section "389. SET -- POSITIONAL PARAMETERS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -- a b c; echo $1 $2 $3' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; echo $1 $2 $3' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "set -- sets positional parameters"
  else
      fail "set -- sets positional parameters" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; echo $#' 2>&1)
  if [ "$result" = "5" ]; then
      pass "set -- updates \$#"
  else
      fail "set -- updates \$#" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c; set --; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; set --; echo $#' 2>&1)
  if [ "$result" = "0" ]; then
      pass "set -- clears positional parameters"
  else
      fail "set -- clears positional parameters" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- "a b" c; echo $1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- "a b" c; echo $1' 2>&1)
  if [ "$result" = "a b" ]; then
      pass "set -- preserves quoted args"
  else
  section "390. READ BUILTIN BASIC"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello" | { read x; echo $x; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello" | { read x; echo $x; }' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "read basic input"
  else
      fail "read basic input" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "one two three" | { read a b c; echo "$a|$b|$c"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "one two three" | { read a b c; echo "$a|$b|$c"; }' 2>&1)
  if [ "$result" = "one|two|three" ]; then
      pass "read multiple variables"
  else
      fail "read multiple variables" "one|two|three" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "one two three four" | { read a b; echo "$a|$b"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "one two three four" | { read a b; echo "$a|$b"; }' 2>&1)
  if [ "$result" = "one|two three four" ]; then
      pass "read remaining into last variable"
  else
  section "391. READ WITH IFS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "a:b:c" | { IFS=: read x y z; echo "$x|$y|$z"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "a:b:c" | { IFS=: read x y z; echo "$x|$y|$z"; }' 2>&1)
  if [ "$result" = "a|b|c" ]; then
      pass "read with custom IFS"
  else
      fail "read with custom IFS" "a|b|c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "a::c" | { IFS=: read x y z; echo "$x|$y|$z"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "a::c" | { IFS=: read x y z; echo "$x|$y|$z"; }' 2>&1)
  if [ "$result" = "a||c" ]; then
      pass "read with empty field"
  else
      fail "read with empty field" "a||c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "  a  b  " | { read x y; echo ">$x|$y<"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "  a  b  " | { read x y; echo ">$x|$y<"; }' 2>&1)
  if [ "$result" = ">a|b<" ]; then
      pass "read strips leading/trailing whitespace"
  else
  section "392. READ -r (RAW MODE)"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello\\nworld" | { read -r x; echo "$x"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello\\nworld" | { read -r x; echo "$x"; }' 2>&1)
  if [ "$result" = 'hello\nworld' ]; then
      pass "read -r preserves backslashes"
  else
  # POSIX: read without -r joins lines ending with backslash (line continuation)
  # printf with single quotes produces: line<backslash><newline>continued<newline>
  # read joins: line + continued = linecontinued
 -result=$("$FORTSH_BIN" -c 'printf '"'"'line\\\ncontinued\n'"'"' | { read x; echo "$x"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf '"'"'line\\\ncontinued\n'"'"' | { read x; echo "$x"; }' 2>&1)
  if [ "$result" = "linecontinued" ]; then
      pass "read without -r joins continued lines"
  else
  section "393. READ EXIT STATUS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "test" | { read x; echo $?; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "test" | { read x; echo $?; }' 2>&1)
  if [ "$result" = "0" ]; then
      pass "read returns 0 on success"
  else
      fail "read returns 0 on success" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo -n "" | { read x; echo $?; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo -n "" | { read x; echo $?; }' 2>&1)
  if [ "$result" = "1" ]; then
      pass "read returns non-zero on EOF"
  else
  section "394. SHIFT BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -- a b c d; shift; echo $1 $2 $3' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d; shift; echo $1 $2 $3' 2>&1)
  if [ "$result" = "b c d" ]; then
      pass "shift removes first parameter"
  else
      fail "shift removes first parameter" "b c d" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 2; echo $1 $2 $3' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; shift 2; echo $1 $2 $3' 2>&1)
  if [ "$result" = "c d e" ]; then
      pass "shift n removes n parameters"
  else
      fail "shift n removes n parameters" "c d e" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; shift; echo $#' 2>&1)
  if [ "$result" = "2" ]; then
      pass "shift updates \$#"
  else
      fail "shift updates \$#" "2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a; shift 5 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a; shift 5 2>/dev/null; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "shift beyond count returns error"
  else
  section "395. SPECIAL PARAMETERS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -- a b c; echo "$@"' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; echo "$@"' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "\$@ expands all positional parameters"
  else
      fail "\$@ expands all positional parameters" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c; echo "$*"' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; echo "$*"' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "\$* expands all positional parameters"
  else
      fail "\$* expands all positional parameters" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c; for x in "$@"; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; for x in "$@"; do echo "[$x]"; done' 2>&1)
  expected=$(printf "[a]\n[b]\n[c]")
  if [ "$result" = "$expected" ]; then
      pass "\"\$@\" preserves separate arguments"
      fail "\"\$@\" preserves separate arguments" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- "a b" c; for x in "$@"; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- "a b" c; for x in "$@"; do echo "[$x]"; done' 2>&1)
  expected=$(printf "[a b]\n[c]")
  if [ "$result" = "$expected" ]; then
      pass "\"\$@\" preserves quoted arguments"
      fail "\"\$@\" preserves quoted arguments" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $$' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $$' 2>&1)
  if echo "$result" | grep -qE '^[0-9]+$' && [ "$result" -gt 0 ]; then
      pass "\$\$ returns PID"
  else
      fail "\$\$ returns PID" "numeric PID" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "\$? returns exit status"
  else
  section "396. IFS WORD SPLITTING"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="a:b:c"; IFS=:; for w in $x; do echo "[$w]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a:b:c"; IFS=:; for w in $x; do echo "[$w]"; done' 2>&1)
  expected=$(printf "[a]\n[b]\n[c]")
  if [ "$result" = "$expected" ]; then
      pass "IFS changes word splitting"
      fail "IFS changes word splitting" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a::c"; IFS=:; set -- $x; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a::c"; IFS=:; set -- $x; echo $#' 2>&1)
  if [ "$result" = "3" ]; then
      pass "IFS empty fields create arguments"
  else
      fail "IFS empty fields create arguments" "3" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'IFS=:; x="a:b:c"; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=:; x="a:b:c"; echo $x' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "IFS affects echo output"
  else
      fail "IFS affects echo output" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'IFS=""; x="a b c"; for w in $x; do echo "[$w]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=""; x="a b c"; for w in $x; do echo "[$w]"; done' 2>&1)
  if [ "$result" = "[a b c]" ]; then
      pass "Empty IFS prevents splitting"
  else
      fail "Empty IFS prevents splitting" "[a b c]" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset IFS; x="a  b"; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset IFS; x="a  b"; echo $x' 2>&1)
  if [ "$result" = "a b" ]; then
      pass "unset IFS uses default"
  else
      fail "unset IFS uses default" "a b" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'IFS=",;"; x="a,b;c"; set -- $x; echo $1 $2 $3' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=",;"; x="a,b;c"; set -- $x; echo $1 $2 $3' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "IFS with multiple characters"
  else
  section "397. ALIAS BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'alias ll="ls -la"; alias ll' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias ll="ls -la"; alias ll' 2>&1)
  if echo "$result" | grep -q "ls -la\|ll="; then
      pass "alias defines and shows alias"
  else
  # Note: Aliases defined in -c mode aren't expanded in the same command line
  # This matches bash behavior - aliases are expanded at parse time
 -result=$("$FORTSH_BIN" -c 'alias greeting="echo hello"; alias greeting' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias greeting="echo hello"; alias greeting' 2>&1)
  if echo "$result" | grep -q "echo hello"; then
      pass "alias defines correctly (matches bash)"
  else
      fail "alias defines correctly (matches bash)" "echo hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'alias x="echo a"; alias y="echo b"; alias | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias x="echo a"; alias y="echo b"; alias | wc -l' 2>&1)
  if [ "$result" -ge 2 ] 2>/dev/null; then
      pass "alias lists all aliases"
  else
      fail "alias lists all aliases" "at least 2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'alias greet="echo hi"; unalias greet; greet 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias greet="echo hi"; unalias greet; greet 2>/dev/null; echo $?' 2>&1)
  if echo "$result" | grep -qE "127|1"; then
      pass "unalias removes alias"
  else
  fi
  # Note: Test redefinition by checking alias output (execution won't work in same line)
 -result=$("$FORTSH_BIN" -c 'alias foo="echo one"; alias foo="echo two"; alias foo' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias foo="echo one"; alias foo="echo two"; alias foo' 2>&1)
  if echo "$result" | grep -q "echo two"; then
      pass "alias can be redefined"
  else
  section "398. EXPORT BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'export TESTVAR=hello; echo $TESTVAR' 2>&1)
 +result=$("$SHELL_BIN" -c 'export TESTVAR=hello; echo $TESTVAR' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "export sets and exports variable"
  else
      fail "export sets and exports variable" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'MYVAR=world; export MYVAR; echo $MYVAR' 2>&1)
 +result=$("$SHELL_BIN" -c 'MYVAR=world; export MYVAR; echo $MYVAR' 2>&1)
  if [ "$result" = "world" ]; then
      pass "export existing variable"
  else
      fail "export existing variable" "world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'export X=1 Y=2 Z=3; echo $X $Y $Z' 2>&1)
 +result=$("$SHELL_BIN" -c 'export X=1 Y=2 Z=3; echo $X $Y $Z' 2>&1)
  if [ "$result" = "1 2 3" ]; then
      pass "export multiple variables"
  else
      fail "export multiple variables" "1 2 3" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'export SUBTEST=value; sh -c "echo \$SUBTEST"' 2>&1)
 +result=$("$SHELL_BIN" -c 'export SUBTEST=value; sh -c "echo \$SUBTEST"' 2>&1)
  if [ "$result" = "value" ]; then
      pass "exported var visible in subshell"
  else
  section "399. READONLY BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'readonly CONST=42; echo $CONST' 2>&1)
 +result=$("$SHELL_BIN" -c 'readonly CONST=42; echo $CONST' 2>&1)
  if [ "$result" = "42" ]; then
      pass "readonly sets variable"
  else
      fail "readonly sets variable" "42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'readonly RO=1; RO=2 2>&1; echo $RO' 2>&1)
 +result=$("$SHELL_BIN" -c 'readonly RO=1; RO=2 2>&1; echo $RO' 2>&1)
  if echo "$result" | grep -q "1"; then
      pass "readonly prevents modification"
  else
      fail "readonly prevents modification" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'readonly A=1 B=2; echo $A $B' 2>&1)
 +result=$("$SHELL_BIN" -c 'readonly A=1 B=2; echo $A $B' 2>&1)
  if [ "$result" = "1 2" ]; then
      pass "readonly multiple variables"
  else
  section "400. UNSET BUILTIN"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=hello; unset x; echo "${x:-unset}"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello; unset x; echo "${x:-unset}"' 2>&1)
  if [ "$result" = "unset" ]; then
      pass "unset removes variable"
  else
      fail "unset removes variable" "unset" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=1; y=2; unset x y; echo "${x:-a} ${y:-b}"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=1; y=2; unset x y; echo "${x:-a} ${y:-b}"' 2>&1)
  if [ "$result" = "a b" ]; then
      pass "unset multiple variables"
  else
      fail "unset multiple variables" "a b" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { echo hi; }; unset -f f; type f 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo hi; }; unset -f f; type f 2>/dev/null; echo $?' 2>&1)
  if echo "$result" | grep -qE "1|127"; then
      pass "unset -f removes function"
  else
  # =====================================
  # Basic option parsing
 -result=$("$FORTSH_BIN" -c 'set -- -a; getopts "ab" opt; echo $opt' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -a; getopts "ab" opt; echo $opt' 2>&1)
  if [ "$result" = "a" ]; then
      pass "getopts parses simple option"
  else
  fi
  # Option with argument
 -result=$("$FORTSH_BIN" -c 'set -- -a value; getopts "a:" opt; echo "$OPTARG"' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -a value; getopts "a:" opt; echo "$OPTARG"' 2>&1)
  if [ "$result" = "value" ]; then
      pass "getopts sets OPTARG"
  else
  fi
  # OPTIND increment
 -result=$("$FORTSH_BIN" -c 'set -- -a -b; getopts "ab" opt; getopts "ab" opt; echo $OPTIND' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -a -b; getopts "ab" opt; getopts "ab" opt; echo $OPTIND' 2>&1)
  if [ "$result" = "3" ]; then
      pass "getopts increments OPTIND"
  else
  fi
  # Multiple options in loop
 -result=$("$FORTSH_BIN" -c 'set -- -a -b -c; while getopts "abc" opt; do echo -n $opt; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -a -b -c; while getopts "abc" opt; do echo -n $opt; done' 2>&1)
  if [ "$result" = "abc" ]; then
      pass "getopts in while loop"
  else
  fi
  # Invalid option handling
 -result=$("$FORTSH_BIN" -c 'set -- -z; getopts "ab" opt 2>/dev/null; echo $opt' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -z; getopts "ab" opt 2>/dev/null; echo $opt' 2>&1)
  if [ "$result" = "?" ]; then
      pass "getopts returns ? for invalid option"
  else
  fi
  # Silent mode with leading colon
 -result=$("$FORTSH_BIN" -c 'set -- -a; getopts ":a:b" opt; echo $opt' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -a; getopts ":a:b" opt; echo $opt' 2>&1)
  if [ "$result" = ":" ] || [ "$result" = "a" ]; then
      pass "getopts silent mode with colon"
  else
  fi
  # Reset OPTIND
 -result=$("$FORTSH_BIN" -c 'set -- -a; getopts "a" opt; OPTIND=1; getopts "a" opt; echo $opt' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- -a; getopts "a" opt; OPTIND=1; getopts "a" opt; echo $opt' 2>&1)
  if [ "$result" = "a" ]; then
      pass "OPTIND reset allows reparse"
  else
  # =====================================
  # type finds commands
 -result=$("$FORTSH_BIN" -c 'type echo' 2>&1)
 +result=$("$SHELL_BIN" -c 'type echo' 2>&1)
  if echo "$result" | grep -qE "echo|builtin|/"; then
      pass "type finds echo"
  else
  fi
  # type returns error for unknown
 -result=$("$FORTSH_BIN" -c 'type nonexistent_xyz_cmd 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'type nonexistent_xyz_cmd 2>/dev/null; echo $?' 2>&1)
  if [ "$result" != "0" ]; then
      pass "type returns error for unknown command"
  else
  fi
  # type finds functions
 -result=$("$FORTSH_BIN" -c 'myfunc() { :; }; type myfunc' 2>&1)
 +result=$("$SHELL_BIN" -c 'myfunc() { :; }; type myfunc' 2>&1)
  if echo "$result" | grep -qE "myfunc|function"; then
      pass "type finds functions"
  else
  fi
  # type finds aliases
 -result=$("$FORTSH_BIN" -c 'alias myalias=echo; type myalias' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias myalias=echo; type myalias' 2>&1)
  if echo "$result" | grep -qE "myalias|alias"; then
      pass "type finds aliases"
  else
  fi
  # type finds builtins
 -result=$("$FORTSH_BIN" -c 'type cd' 2>&1)
 +result=$("$SHELL_BIN" -c 'type cd' 2>&1)
  if echo "$result" | grep -qE "cd|builtin"; then
      pass "type identifies builtins"
  else
  # =====================================
  # command -v finds commands
 -result=$("$FORTSH_BIN" -c 'command -v echo' 2>&1)
 +result=$("$SHELL_BIN" -c 'command -v echo' 2>&1)
  if [ -n "$result" ]; then
      pass "command -v finds echo"
  else
  fi
  # command -v returns empty for unknown
 -result=$("$FORTSH_BIN" -c 'command -v nonexistent_xyz_cmd; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'command -v nonexistent_xyz_cmd; echo $?' 2>&1)
  if [ "$result" != "0" ]; then
      pass "command -v returns error for unknown"
  else
  fi
  # command bypasses functions
 -result=$("$FORTSH_BIN" -c 'echo() { printf "FUNC"; }; command echo hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo() { printf "FUNC"; }; command echo hello' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "command bypasses function"
  else
  fi
  # command bypasses aliases
 -result=$("$FORTSH_BIN" -c 'alias echo="printf ALIAS"; command echo hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'alias echo="printf ALIAS"; command echo hello' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "command bypasses alias"
  else
  # =====================================
  # trap with empty action
 -result=$("$FORTSH_BIN" -c 'trap "" INT; trap' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "" INT; trap' 2>&1)
  if echo "$result" | grep -qE "INT|''"; then
      pass "trap with empty action (ignore signal)"
  else
  fi
  # trap - removes trap
 -result=$("$FORTSH_BIN" -c 'trap "echo x" EXIT; trap - EXIT; trap' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo x" EXIT; trap - EXIT; trap' 2>&1)
  if ! echo "$result" | grep -q "EXIT"; then
      pass "trap - removes trap"
  else
  fi
  # Multiple traps
 -result=$("$FORTSH_BIN" -c 'trap "echo INT" INT; trap "echo TERM" TERM; trap | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo INT" INT; trap "echo TERM" TERM; trap | wc -l' 2>&1)
  if [ "$result" -ge 2 ] 2>/dev/null; then
      pass "Multiple traps can be set"
  else
  fi
  # trap with no args lists traps
 -result=$("$FORTSH_BIN" -c 'trap "echo x" INT; trap' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo x" INT; trap' 2>&1)
  if [ -n "$result" ]; then
      pass "trap with no args lists traps"
  else
  fi
  # EXIT trap runs on exit
 -result=$("$FORTSH_BIN" -c 'trap "echo EXITING" EXIT; exit 0' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo EXITING" EXIT; exit 0' 2>&1)
  if [ "$result" = "EXITING" ]; then
      pass "EXIT trap executes on exit"
  else
  # =====================================
  # hash without args
 -result=$("$FORTSH_BIN" -c 'hash 2>&1; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'hash 2>&1; echo $?' 2>&1)
  # hash returns 0 even if empty
  pass "hash builtin exists"
  # hash -r clears cache
 -result=$("$FORTSH_BIN" -c 'ls >/dev/null 2>&1; hash -r; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'ls >/dev/null 2>&1; hash -r; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "hash -r clears cache"
  else
  # =====================================
  # wait with no args
 -result=$("$FORTSH_BIN" -c 'sleep 0.1 & sleep 0.1 & wait; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'sleep 0.1 & sleep 0.1 & wait; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "wait with no args waits for all"
  else
  fi
  # wait with specific PID
 -result=$("$FORTSH_BIN" -c 'sleep 0.1 & pid=$!; wait $pid; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'sleep 0.1 & pid=$!; wait $pid; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "wait with PID"
  else
  fi
  # wait preserves exit status
 -result=$("$FORTSH_BIN" -c '(exit 42) & pid=$!; wait $pid; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '(exit 42) & pid=$!; wait $pid; echo $?' 2>&1)
  if [ "$result" = "42" ]; then
      pass "wait preserves exit status"
  else
  # =====================================
  # ulimit -a shows limits
 -result=$("$FORTSH_BIN" -c 'ulimit -a 2>&1' | head -5)
 +result=$("$SHELL_BIN" -c 'ulimit -a 2>&1' | head -5)
  if [ -n "$result" ]; then
      pass "ulimit -a shows limits"
  else
  fi
  # ulimit shows soft limit
 -result=$("$FORTSH_BIN" -c 'ulimit 2>&1' | head -1)
 +result=$("$SHELL_BIN" -c 'ulimit 2>&1' | head -1)
  if [ -n "$result" ]; then
      pass "ulimit shows default limit"
  else
  # =====================================
  # read single variable
 -result=$("$FORTSH_BIN" -c 'echo "hello" | { read x; echo $x; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello" | { read x; echo $x; }' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "read single variable"
  else
  fi
  # read multiple variables
 -result=$("$FORTSH_BIN" -c 'echo "a b c" | { read x y z; echo "$x:$y:$z"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "a b c" | { read x y z; echo "$x:$y:$z"; }' 2>&1)
  if [ "$result" = "a:b:c" ]; then
      pass "read multiple variables"
  else
  fi
  # read with extra words
 -result=$("$FORTSH_BIN" -c 'echo "a b c d e" | { read x y; echo "$x|$y"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "a b c d e" | { read x y; echo "$x|$y"; }' 2>&1)
  if [ "$result" = "a|b c d e" ]; then
      pass "read extra words to last var"
  else
  # =====================================
  # printf basic
 -result=$("$FORTSH_BIN" -c 'printf "hello\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "hello\n"' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "printf basic"
  else
  fi
  # printf with format
 -result=$("$FORTSH_BIN" -c 'printf "%s world\n" "hello"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s world\n" "hello"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "printf with %s"
  else
  fi
  # printf with number
 -result=$("$FORTSH_BIN" -c 'printf "%d\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%d\n" 42' 2>&1)
  if [ "$result" = "42" ]; then
      pass "printf with %d"
  else
  fi
  # printf width
 -result=$("$FORTSH_BIN" -c 'printf "%5d\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%5d\n" 42' 2>&1)
  if [ "$result" = "   42" ]; then
      pass "printf with width"
  else
  # =====================================
  # echo basic
 -result=$("$FORTSH_BIN" -c 'echo hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "echo basic"
  else
  fi
  # echo multiple args
 -result=$("$FORTSH_BIN" -c 'echo a b c' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo a b c' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "echo multiple args"
  else
  fi
  # echo with quotes
 -result=$("$FORTSH_BIN" -c 'echo "hello world"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello world"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "echo with quotes"
  else
  # =====================================
  # kill -l lists signals
 -result=$("$FORTSH_BIN" -c 'kill -l 2>&1 | head -1')
 +result=$("$SHELL_BIN" -c 'kill -l 2>&1 | head -1')
  if [ -n "$result" ]; then
      pass "kill -l lists signals"
  else
  # =====================================
  # set -e (errexit)
 -result=$("$FORTSH_BIN" -c 'set -e; true; echo reached' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -e; true; echo reached' 2>&1)
  if [ "$result" = "reached" ]; then
      pass "set -e continues on success"
  else
  fi
  # set -x (xtrace)
 -result=$("$FORTSH_BIN" -c 'set -x; echo test 2>&1' | grep -c test)
 +result=$("$SHELL_BIN" -c 'set -x; echo test 2>&1' | grep -c test)
  if [ "$result" -ge 1 ]; then
      pass "set -x traces commands"
  else
  fi
  # set -f (noglob)
 -result=$("$FORTSH_BIN" -c 'set -f; echo *' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -f; echo *' 2>&1)
  if [ "$result" = "*" ]; then
      pass "set -f disables glob"
  else
  fi
  # set +f (enable glob)
 -result=$("$FORTSH_BIN" -c 'set -f; set +f; ls /*.txt 2>/dev/null | wc -l || echo 0' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -f; set +f; ls /*.txt 2>/dev/null | wc -l || echo 0' 2>&1)
  if echo "$result" | grep -qE '^[[:space:]]*[0-9]+[[:space:]]*$'; then
      pass "set +f enables glob"
  else
  # =====================================
  # unset variable
 -result=$("$FORTSH_BIN" -c 'x=value; unset x; echo ${x:-empty}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=value; unset x; echo ${x:-empty}' 2>&1)
  if [ "$result" = "empty" ]; then
      pass "unset removes variable"
  else
  fi
  # unset function
 -result=$("$FORTSH_BIN" -c 'f() { echo hi; }; unset -f f; f 2>/dev/null || echo gone' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo hi; }; unset -f f; f 2>/dev/null || echo gone' 2>&1)
  if [ "$result" = "gone" ]; then
      pass "unset -f removes function"
  else
  fi
  # unset readonly fails
 -result=$("$FORTSH_BIN" -c 'readonly x=1; unset x 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'readonly x=1; unset x 2>/dev/null; echo $?' 2>&1)
  if [ "$result" != "0" ]; then
      pass "unset readonly fails"
  else
  # =====================================
  # basic shift
 -result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; shift; echo $1' 2>&1)
  if [ "$result" = "b" ]; then
      pass "shift removes first arg"
  else
  fi
  # shift with count
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 3; echo $1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; shift 3; echo $1' 2>&1)
  if [ "$result" = "d" ]; then
      pass "shift with count"
  else
  fi
  # shift updates $#
 -result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; shift; echo $#' 2>&1)
  if [ "$result" = "2" ]; then
      pass "shift updates arg count"
  else
  # =====================================
  # true returns 0
 -result=$("$FORTSH_BIN" -c 'true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'true; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "true returns 0"
  else
  fi
  # false returns 1
 -result=$("$FORTSH_BIN" -c 'false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "false returns 1"
  else
  fi
  # true in conditional
 -result=$("$FORTSH_BIN" -c 'if true; then echo yes; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'if true; then echo yes; fi' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "true in if condition"
  else
  fi
  # false in conditional
 -result=$("$FORTSH_BIN" -c 'if false; then echo no; else echo yes; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'if false; then echo no; else echo yes; fi' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "false in if condition"
  else
  # =====================================
  # colon returns 0
 -result=$("$FORTSH_BIN" -c ':; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c ':; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "colon returns 0"
  else
  fi
  # colon with args (ignored)
 -result=$("$FORTSH_BIN" -c ': arg1 arg2 arg3; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c ': arg1 arg2 arg3; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "colon ignores args"
  else
  fi
  # colon in loop condition
 -result=$("$FORTSH_BIN" -c 'i=0; while :; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while :; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i' 2>&1)
  if [ "$result" = "3" ]; then
      pass "colon as infinite loop condition"
  else
  # =====================================
  # pwd returns current dir
 -result=$("$FORTSH_BIN" -c 'pwd | grep -c "^/"' 2>&1)
 +result=$("$SHELL_BIN" -c 'pwd | grep -c "^/"' 2>&1)
  if [ "$result" = "1" ]; then
      pass "pwd returns absolute path"
  else
  fi
  # pwd after cd
 -result=$("$FORTSH_BIN" -c 'cd /tmp && pwd' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /tmp && pwd' 2>&1)
  if [ "$result" = "/tmp" ]; then
      pass "pwd after cd"
  else
  # =====================================
  # cd to absolute path
 -result=$("$FORTSH_BIN" -c 'cd /tmp && pwd' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /tmp && pwd' 2>&1)
  if [ "$result" = "/tmp" ]; then
      pass "cd to absolute path"
  else
  fi
  # cd - returns to OLDPWD
 -result=$("$FORTSH_BIN" -c 'cd /tmp; cd /; cd - 2>&1' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /tmp; cd /; cd - 2>&1' 2>&1)
  if echo "$result" | grep -q "tmp"; then
      pass "cd - returns to OLDPWD"
  else
  fi
  # cd nonexistent fails
 -result=$("$FORTSH_BIN" -c 'cd /nonexistent_dir_xyz 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /nonexistent_dir_xyz 2>/dev/null; echo $?' 2>&1)
  if [ "$result" != "0" ]; then
      pass "cd nonexistent fails"
  else
  # =====================================
  # times outputs something
 -result=$("$FORTSH_BIN" -c 'times 2>&1 | head -1 || echo skipped')
 +result=$("$SHELL_BIN" -c 'times 2>&1 | head -1 || echo skipped')
  if [ -n "$result" ]; then
      pass "times outputs timing info"
  else
  # =====================================
  # exit with code
 -result=$("$FORTSH_BIN" -c 'exit 42' 2>&1; echo $?)
 +result=$("$SHELL_BIN" -c 'exit 42' 2>&1; echo $?)
  if [ "$result" = "42" ]; then
      pass "exit with code"
  else
  fi
  # exit default 0
 -result=$("$FORTSH_BIN" -c 'exit' 2>&1; echo $?)
 +result=$("$SHELL_BIN" -c 'exit' 2>&1; echo $?)
  if [ "$result" = "0" ]; then
      pass "exit default 0"
  else
  fi
  # exit from subshell
 -result=$("$FORTSH_BIN" -c '(exit 7); echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '(exit 7); echo $?' 2>&1)
  if [ "$result" = "7" ]; then
      pass "exit from subshell"
  else

suites/posix/posix_compliance_printf.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "358. PRINTF BASIC STRING FORMAT %s"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%s\n" "hello"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s\n" "hello"' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "printf %s basic string"
  else
      fail "printf %s basic string" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%s %s\n" "hello" "world"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s %s\n" "hello" "world"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "printf %s multiple arguments"
  else
      fail "printf %s multiple arguments" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%s" ""' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s" ""' 2>&1)
  if [ "$result" = "" ]; then
      pass "printf %s empty string"
  else
      fail "printf %s empty string" "(empty)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%.3s\n" "hello"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%.3s\n" "hello"' 2>&1)
  if [ "$result" = "hel" ]; then
      pass "printf %.3s precision truncates"
  else
      fail "printf %.3s precision truncates" "hel" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%10s\n" "hi"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%10s\n" "hi"' 2>&1)
  if [ "$result" = "        hi" ]; then
      pass "printf %10s width right-align"
  else
      fail "printf %10s width right-align" "        hi" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%-10s|\n" "hi"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%-10s|\n" "hi"' 2>&1)
  if [ "$result" = "hi        |" ]; then
      pass "printf %-10s width left-align"
  else
  section "359. PRINTF INTEGER FORMATS %d %i"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%d\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%d\n" 42' 2>&1)
  if [ "$result" = "42" ]; then
      pass "printf %d basic decimal"
  else
      fail "printf %d basic decimal" "42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%i\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%i\n" 42' 2>&1)
  if [ "$result" = "42" ]; then
      pass "printf %i basic integer"
  else
      fail "printf %i basic integer" "42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%d\n" -42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%d\n" -42' 2>&1)
  if [ "$result" = "-42" ]; then
      pass "printf %d negative number"
  else
      fail "printf %d negative number" "-42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%5d\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%5d\n" 42' 2>&1)
  if [ "$result" = "   42" ]; then
      pass "printf %5d width padding"
  else
      fail "printf %5d width padding" "   42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%05d\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%05d\n" 42' 2>&1)
  if [ "$result" = "00042" ]; then
      pass "printf %05d zero padding"
  else
      fail "printf %05d zero padding" "00042" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%-5d|\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%-5d|\n" 42' 2>&1)
  if [ "$result" = "42   |" ]; then
      pass "printf %-5d left-align"
  else
      fail "printf %-5d left-align" "42   |" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%+d\n" 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%+d\n" 42' 2>&1)
  if [ "$result" = "+42" ]; then
      pass "printf %+d explicit plus sign"
  else
  section "360. PRINTF OCTAL AND HEX FORMATS %o %x %X"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%o\n" 8' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%o\n" 8' 2>&1)
  if [ "$result" = "10" ]; then
      pass "printf %o octal format"
  else
      fail "printf %o octal format" "10" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%x\n" 255' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%x\n" 255' 2>&1)
  if [ "$result" = "ff" ]; then
      pass "printf %x lowercase hex"
  else
      fail "printf %x lowercase hex" "ff" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%X\n" 255' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%X\n" 255' 2>&1)
  if [ "$result" = "FF" ]; then
      pass "printf %X uppercase hex"
  else
      fail "printf %X uppercase hex" "FF" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%#x\n" 255' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%#x\n" 255' 2>&1)
  if [ "$result" = "0xff" ]; then
      pass "printf %#x alternate form"
  else
      fail "printf %#x alternate form" "0xff" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%#o\n" 8' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%#o\n" 8' 2>&1)
  if [ "$result" = "010" ]; then
      pass "printf %#o alternate octal form"
  else
  section "361. PRINTF CHARACTER FORMAT %c"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%c\n" A' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%c\n" A' 2>&1)
  if [ "$result" = "A" ]; then
      pass "printf %c single character"
  else
      fail "printf %c single character" "A" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%c\n" "hello"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%c\n" "hello"' 2>&1)
  if [ "$result" = "h" ]; then
      pass "printf %c first char of string"
  else
      fail "printf %c first char of string" "h" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%c%c%c\n" a b c' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%c%c%c\n" a b c' 2>&1)
  if [ "$result" = "abc" ]; then
      pass "printf %c multiple chars"
  else
  section "362. PRINTF ESCAPE SEQUENCES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "hello\nworld\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "hello\nworld\n"' 2>&1)
  expected=$(printf "hello\nworld")
  if [ "$result" = "$expected" ]; then
      pass "printf \\n newline"
      fail "printf \\n newline" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "a\tb\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "a\tb\n"' 2>&1)
  expected=$(printf "a\tb")
  if [ "$result" = "$expected" ]; then
      pass "printf \\t tab"
      fail "printf \\t tab" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "back\\\\slash\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "back\\\\slash\n"' 2>&1)
  if [ "$result" = 'back\slash' ]; then
      pass "printf \\\\ literal backslash"
  else
      fail "printf \\\\ literal backslash" 'back\slash' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "100%%\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "100%%\n"' 2>&1)
  if [ "$result" = "100%" ]; then
      pass "printf %% literal percent"
  else
      fail "printf %% literal percent" "100%" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "\101\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "\101\n"' 2>&1)
  if [ "$result" = "A" ]; then
      pass "printf \\NNN octal escape"
  else
  section "363. PRINTF %b ESCAPE INTERPRETATION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%b\n" "hello\nworld"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%b\n" "hello\nworld"' 2>&1)
  expected=$(printf "hello\nworld")
  if [ "$result" = "$expected" ]; then
      pass "printf %b interprets backslash escapes"
      fail "printf %b interprets backslash escapes" "(newline)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%b\n" "tab\there"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%b\n" "tab\there"' 2>&1)
  expected=$(printf "tab\there")
  if [ "$result" = "$expected" ]; then
      pass "printf %b interprets \\t"
  section "364. PRINTF FORMAT REUSE"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%s\n" one two three' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s\n" one two three' 2>&1)
  expected=$(printf "one\ntwo\nthree")
  if [ "$result" = "$expected" ]; then
      pass "printf format reused for extra args"
      fail "printf format reused for extra args" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%d " 1 2 3 4 5; printf "\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%d " 1 2 3 4 5; printf "\n"' 2>&1)
  if [ "$result" = "1 2 3 4 5 " ]; then
      pass "printf %d reused for multiple integers"
  else
  section "365. PRINTF WITH VARIABLES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="hello"; printf "%s\n" "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello"; printf "%s\n" "$x"' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "printf with variable argument"
  else
      fail "printf with variable argument" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'n=42; printf "Value: %d\n" "$n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'n=42; printf "Value: %d\n" "$n"' 2>&1)
  if [ "$result" = "Value: 42" ]; then
      pass "printf integer from variable"
  else
      fail "printf integer from variable" "Value: 42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'fmt="%s: %d\n"; printf "$fmt" name 42' 2>&1)
 +result=$("$SHELL_BIN" -c 'fmt="%s: %d\n"; printf "$fmt" name 42' 2>&1)
  if [ "$result" = "name: 42" ]; then
      pass "printf format from variable"
  else
  section "366. PRINTF DYNAMIC WIDTH AND PRECISION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%*s\n" 10 hi' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%*s\n" 10 hi' 2>&1)
  if [ "$result" = "        hi" ]; then
      pass "printf %*s dynamic width"
  else
      fail "printf %*s dynamic width" "        hi" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%.*s\n" 3 hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%.*s\n" 3 hello' 2>&1)
  if [ "$result" = "hel" ]; then
      pass "printf %.*s dynamic precision"
  else
      fail "printf %.*s dynamic precision" "hel" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%*.*s\n" 10 3 hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%*.*s\n" 10 3 hello' 2>&1)
  if [ "$result" = "       hel" ]; then
      pass "printf %*.*s dynamic width and precision"
  else
  section "367. PRINTF RETURN VALUE"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%s" "test"; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s" "test"; echo $?' 2>&1)
  if echo "$result" | grep -q "0"; then
      pass "printf returns 0 on success"
  else
  section "368. PRINTF EDGE CASES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'printf "%d\n" 0' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%d\n" 0' 2>&1)
  if [ "$result" = "0" ]; then
      pass "printf %d zero"
  else
      fail "printf %d zero" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "%s\n" ""' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s\n" ""' 2>&1)
  if [ "$result" = "" ]; then
      pass "printf empty argument"
  else
      fail "printf empty argument" "(empty)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "no format"' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "no format"' 2>&1)
  if [ "$result" = "no format" ]; then
      pass "printf literal string no format"
  else
      fail "printf literal string no format" "no format" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf ""' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf ""' 2>&1)
  if [ "$result" = "" ]; then
      pass "printf empty format string"
  else

suites/posix/posix_compliance_quoting.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "446. SINGLE QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c "echo 'hello world'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'hello world'" 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Single quotes preserve spaces"
  else
      fail "Single quotes preserve spaces" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "x=test; echo '\$x'" 2>&1)
 +result=$("$SHELL_BIN" -c "x=test; echo '\$x'" 2>&1)
  if [ "$result" = '$x' ]; then
      pass "Single quotes prevent variable expansion"
  else
      fail "Single quotes prevent variable expansion" '$x' "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'back\\slash'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'back\\slash'" 2>&1)
  if [ "$result" = 'back\slash' ]; then
      pass "Single quotes preserve backslash"
  else
      fail "Single quotes preserve backslash" 'back\slash' "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'has \"double\" quotes'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'has \"double\" quotes'" 2>&1)
  if [ "$result" = 'has "double" quotes' ]; then
      pass "Single quotes preserve double quotes"
  else
      fail "Single quotes preserve double quotes" 'has "double" quotes' "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo '\$(echo no)'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo '\$(echo no)'" 2>&1)
  if [ "$result" = '$(echo no)' ]; then
      pass "Single quotes prevent command substitution"
  else
  section "447. DOUBLE QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello world"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello world"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Double quotes preserve spaces"
  else
      fail "Double quotes preserve spaces" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=test; echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=test; echo "$x"' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Double quotes allow variable expansion"
  else
      fail "Double quotes allow variable expansion" "test" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "$(echo hello)"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "$(echo hello)"' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Double quotes allow command substitution"
  else
      fail "Double quotes allow command substitution" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "has '\''single'\'' quotes"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "has '\''single'\'' quotes"' 2>&1)
  if [ "$result" = "has 'single' quotes" ]; then
      pass "Double quotes preserve single quotes"
  else
      fail "Double quotes preserve single quotes" "has 'single' quotes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "escaped \"quote\""' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "escaped \"quote\""' 2>&1)
  if [ "$result" = 'escaped "quote"' ]; then
      pass "Double quotes with escaped quotes"
  else
      fail "Double quotes with escaped quotes" 'escaped "quote"' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "back\\slash"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "back\\slash"' 2>&1)
  if [ "$result" = 'back\slash' ]; then
      pass "Double quotes with escaped backslash"
  else
      fail "Double quotes with escaped backslash" 'back\slash' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "dollar\$sign"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "dollar\$sign"' 2>&1)
  if [ "$result" = 'dollar$sign' ]; then
      pass "Double quotes with escaped dollar"
  else
  section "448. BACKSLASH ESCAPING"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello\ world' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello\ world' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Backslash escapes space"
  else
      fail "Backslash escapes space" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=test; echo \$x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=test; echo \$x' 2>&1)
  if [ "$result" = '$x' ]; then
      pass "Backslash escapes dollar sign"
  else
      fail "Backslash escapes dollar sign" '$x' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo back\\slash' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo back\\slash' 2>&1)
  if [ "$result" = 'back\slash' ]; then
      pass "Backslash escapes backslash"
  else
      fail "Backslash escapes backslash" 'back\slash' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo hello\
 +result=$("$SHELL_BIN" -c 'echo hello\
  world' 2>&1)
  if [ "$result" = "helloworld" ]; then
      pass "Backslash-newline line continuation"
  section "449. MIXED QUOTING"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello"'\''world'\''' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello"'\''world'\''' 2>&1)
  # Adjacent quoted strings concatenate: "hello" + 'world' = helloworld
  if [ "$result" = "helloworld" ]; then
      pass "Adjacent double and single quotes"
      fail "Adjacent double and single quotes" "helloworld" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=val; echo "$x"'\''$x'\''' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=val; echo "$x"'\''$x'\''' 2>&1)
  if [ "$result" = 'val$x' ]; then
      pass "Mixed expansion and literal"
  else
      fail "Mixed expansion and literal" 'val$x' "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'don'\\''t'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'don'\\''t'" 2>&1)
  if [ "$result" = "don't" ]; then
      pass "Single quote in single quoted string"
  else
  section "450. QUOTING SPECIAL CHARACTERS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "semi;colon"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "semi;colon"' 2>&1)
  if [ "$result" = "semi;colon" ]; then
      pass "Semicolon in double quotes"
  else
      fail "Semicolon in double quotes" "semi;colon" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'pipe|char'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'pipe|char'" 2>&1)
  if [ "$result" = "pipe|char" ]; then
      pass "Pipe in single quotes"
  else
      fail "Pipe in single quotes" "pipe|char" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "ampersand&here"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "ampersand&here"' 2>&1)
  if [ "$result" = "ampersand&here" ]; then
      pass "Ampersand in double quotes"
  else
      fail "Ampersand in double quotes" "ampersand&here" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'less<greater>'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'less<greater>'" 2>&1)
  if [ "$result" = "less<greater>" ]; then
      pass "Angle brackets in single quotes"
  else
      fail "Angle brackets in single quotes" "less<greater>" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "paren(here)"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "paren(here)"' 2>&1)
  if [ "$result" = "paren(here)" ]; then
      pass "Parentheses in double quotes"
  else
      fail "Parentheses in double quotes" "paren(here)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'star*glob?'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'star*glob?'" 2>&1)
  if [ "$result" = "star*glob?" ]; then
      pass "Glob chars in single quotes"
  else
      fail "Glob chars in single quotes" "star*glob?" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "hash#comment"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hash#comment"' 2>&1)
  if [ "$result" = "hash#comment" ]; then
      pass "Hash in double quotes"
  else
  section "451. EMPTY STRINGS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo ""' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo ""' 2>&1)
  if [ "$result" = "" ]; then
      pass "Empty double-quoted string"
  else
      fail "Empty double-quoted string" "(empty)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo ''" 2>&1)
 +result=$("$SHELL_BIN" -c "echo ''" 2>&1)
  if [ "$result" = "" ]; then
      pass "Empty single-quoted string"
  else
      fail "Empty single-quoted string" "(empty)" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo "[$x]"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo "[$x]"' 2>&1)
  if [ "$result" = "[]" ]; then
      pass "Empty variable in quotes"
  else
      fail "Empty variable in quotes" "[]" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo a "" b' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo a "" b' 2>&1)
  if [ "$result" = "a  b" ]; then
      pass "Empty string preserves word"
  else
  section "452. WORD SPLITTING"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="a b c"; for w in $x; do echo "[$w]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a b c"; for w in $x; do echo "[$w]"; done' 2>&1)
  expected=$(printf "[a]\n[b]\n[c]")
  if [ "$result" = "$expected" ]; then
      pass "Unquoted variable splits on whitespace"
      fail "Unquoted variable splits on whitespace" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a b c"; for w in "$x"; do echo "[$w]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a b c"; for w in "$x"; do echo "[$w]"; done' 2>&1)
  if [ "$result" = "[a b c]" ]; then
      pass "Quoted variable prevents splitting"
  else
      fail "Quoted variable prevents splitting" "[a b c]" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a  b"; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a  b"; echo $x' 2>&1)
  if [ "$result" = "a b" ]; then
      pass "Word splitting collapses spaces"
  else
      fail "Word splitting collapses spaces" "a b" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a  b"; echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a  b"; echo "$x"' 2>&1)
  if [ "$result" = "a  b" ]; then
      pass "Quoting preserves multiple spaces"
  else
  section "453. GLOB PREVENTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "*"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "*"' 2>&1)
  if [ "$result" = "*" ]; then
      pass "Double quotes prevent glob expansion"
  else
      fail "Double quotes prevent glob expansion" "*" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo '[a-z]*'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo '[a-z]*'" 2>&1)
  if [ "$result" = "[a-z]*" ]; then
      pass "Single quotes prevent bracket expansion"
  else
      fail "Single quotes prevent bracket expansion" "[a-z]*" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "?"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "?"' 2>&1)
  if [ "$result" = "?" ]; then
      pass "Double quotes prevent ? expansion"
  else
  section "454. QUOTE IN VARIABLE"
  # =====================================
 -result=$("$FORTSH_BIN" -c "x=\"has 'quotes'\"; echo \"\$x\"" 2>&1)
 +result=$("$SHELL_BIN" -c "x=\"has 'quotes'\"; echo \"\$x\"" 2>&1)
  if [ "$result" = "has 'quotes'" ]; then
      pass "Single quotes inside double-quoted variable"
  else
      fail "Single quotes inside double-quoted variable" "has 'quotes'" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="has \"quotes\""; echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="has \"quotes\""; echo "$x"' 2>&1)
  if [ "$result" = 'has "quotes"' ]; then
      pass "Double quotes inside variable"
  else
  section "455. QUOTING IN ASSIGNMENTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="hello world"; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello world"; echo $x' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Quoted assignment with spaces"
  else
      fail "Quoted assignment with spaces" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "x='no \$expansion'; echo \"\$x\"" 2>&1)
 +result=$("$SHELL_BIN" -c "x='no \$expansion'; echo \"\$x\"" 2>&1)
  if [ "$result" = 'no $expansion' ]; then
      pass "Single-quoted assignment"
  else
      fail "Single-quoted assignment" 'no $expansion' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'y=value; x="with $y"; echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'y=value; x="with $y"; echo "$x"' 2>&1)
  if [ "$result" = "with value" ]; then
      pass "Variable expansion in assignment"
  else
  section "456. QUOTING IN COMMAND SUBSTITUTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=$(echo "hello world"); echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=$(echo "hello world"); echo "$x"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Quotes inside command substitution"
  else
      fail "Quotes inside command substitution" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="$(echo "nested quotes")"; echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="$(echo "nested quotes")"; echo "$x"' 2>&1)
  if [ "$result" = "nested quotes" ]; then
      pass "Nested quotes in command substitution"
  else
  # POSIX: In double quotes, \\\\ (4 backslashes) becomes \\ (2 backslashes)
  # Each pair of \\ in double quotes produces one literal backslash
 -result=$("$FORTSH_BIN" -c 'echo "back\\\\slash"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "back\\\\slash"' 2>&1)
  if [ "$result" = 'back\\slash' ]; then
      pass "Backslash-backslash in double quotes"
  else
      fail "Backslash-backslash in double quotes" 'back\\slash' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "newline\\n"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "newline\\n"' 2>&1)
  if [ "$result" = 'newline\n' ]; then
      pass "Backslash-n in double quotes (literal)"
  else
      fail "Backslash-n in double quotes (literal)" 'newline\n' "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "tab\\t"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "tab\\t"' 2>&1)
  if [ "$result" = 'tab\t' ]; then
      pass "Backslash-t in double quotes (literal)"
  else
  section "458. DOLLAR IN QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "cost: \$5"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "cost: \$5"' 2>&1)
  if [ "$result" = 'cost: $5' ]; then
      pass "Escaped dollar in double quotes"
  else
      fail "Escaped dollar in double quotes" 'cost: $5' "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'cost: \$5'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'cost: \$5'" 2>&1)
  if [ "$result" = 'cost: $5' ]; then
      pass "Dollar in single quotes (literal)"
  else
  section "459. NEWLINE IN QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "line1
 +result=$("$SHELL_BIN" -c 'echo "line1
  line2"' 2>&1)
  expected=$(printf "line1\nline2")
  if [ "$result" = "$expected" ]; then
      fail "Literal newline in double quotes" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'line1
 +result=$("$SHELL_BIN" -c "echo 'line1
  line2'" 2>&1)
  expected=$(printf "line1\nline2")
  if [ "$result" = "$expected" ]; then
  section "460. TAB AND SPACE IN QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "	tab"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "	tab"' 2>&1)
  if printf "%s" "$result" | grep -q "	"; then
      pass "Literal tab in double quotes"
  else
      fail "Literal tab in double quotes" "string with tab" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "  spaces  "' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "  spaces  "' 2>&1)
  if [ "$result" = "  spaces  " ]; then
      pass "Multiple spaces in double quotes"
  else
  section "461. QUOTING IN FOR LOOP"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'for x in "a b" c; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for x in "a b" c; do echo "[$x]"; done' 2>&1)
  expected=$(printf "[a b]\n[c]")
  if [ "$result" = "$expected" ]; then
      pass "Quoted string in for list"
      fail "Quoted string in for list" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'list="a b c"; for x in $list; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'list="a b c"; for x in $list; do echo "[$x]"; done' 2>&1)
  expected=$(printf "[a]\n[b]\n[c]")
  if [ "$result" = "$expected" ]; then
      pass "Unquoted var splits in for"
      fail "Unquoted var splits in for" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'list="a b c"; for x in "$list"; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'list="a b c"; for x in "$list"; do echo "[$x]"; done' 2>&1)
  if [ "$result" = "[a b c]" ]; then
      pass "Quoted var no split in for"
  else
  section "462. QUOTING IN CASE STATEMENT"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="hello world"; case "$x" in "hello world") echo match;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello world"; case "$x" in "hello world") echo match;; esac' 2>&1)
  if [ "$result" = "match" ]; then
      pass "Quoted string in case word"
  else
      fail "Quoted string in case word" "match" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'case "a b" in "a b") echo yes;; *) echo no;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'case "a b" in "a b") echo yes;; *) echo no;; esac' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "Quoted pattern in case"
  else
  section "463. QUOTING SPECIAL SHELL CHARS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello; world"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello; world"' 2>&1)
  if [ "$result" = "hello; world" ]; then
      pass "Semicolon in double quotes"
  else
      fail "Semicolon in double quotes" "hello; world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'a && b'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'a && b'" 2>&1)
  if [ "$result" = "a && b" ]; then
      pass "Double ampersand in single quotes"
  else
      fail "Double ampersand in single quotes" "a && b" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "a || b"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "a || b"' 2>&1)
  if [ "$result" = "a || b" ]; then
      pass "Double pipe in double quotes"
  else
      fail "Double pipe in double quotes" "a || b" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'back\`tick'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'back\`tick'" 2>&1)
  if [ "$result" = 'back`tick' ]; then
      pass "Backtick in single quotes"
  else
  section "464. QUOTING IN ARITHMETIC"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=5; echo $((x + 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=5; echo $((x + 3))' 2>&1)
  if [ "$result" = "8" ]; then
      pass "Unquoted var in arithmetic"
  else
      fail "Unquoted var in arithmetic" "8" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="5"; echo $((x + 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="5"; echo $((x + 3))' 2>&1)
  if [ "$result" = "8" ]; then
      pass "Quoted assignment used in arithmetic"
  else
  section "465. ESCAPE SEQUENCES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello\tworld"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello\tworld"' 2>&1)
  if echo "$result" | grep -q "hello"; then
      pass "Backslash-t in double quotes"
  else
  fi
  # Test backslash-n literal in single quotes (use double backslash for POSIX sh compatibility)
 -result=$("$FORTSH_BIN" -c "echo 'hello\\nworld'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'hello\\nworld'" 2>&1)
  if printf '%s' "$result" | grep -q 'hello.nworld'; then
      pass "Backslash-n literal in single quotes"
  else
  section "466. QUOTING AND WORD SPLITTING"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="a b c"; set -- $x; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a b c"; set -- $x; echo $#' 2>&1)
  if [ "$result" = "3" ]; then
      pass "Unquoted var splits on spaces"
  else
      fail "Unquoted var splits on spaces" "3" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a b c"; set -- "$x"; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a b c"; set -- "$x"; echo $#' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Quoted var prevents splitting"
  else
      fail "Quoted var prevents splitting" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; set -- $x; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; set -- $x; echo $#' 2>&1)
  if [ "$result" = "0" ]; then
      pass "Empty unquoted var produces no args"
  else
      fail "Empty unquoted var produces no args" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; set -- "$x"; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; set -- "$x"; echo $#' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Empty quoted var produces one empty arg"
  else
  section "467. QUOTING SPECIAL PARAMETERS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'set -- a b c; echo "$@" | wc -w' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; echo "$@" | wc -w' 2>&1)
  if [ "$result" -eq 3 ] 2>/dev/null; then
      pass 'Quoted $@ preserves args'
  else
      fail 'Quoted $@ preserves args' "3" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a b c; echo "$*"' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; echo "$*"' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass 'Quoted $* joins args'
  else
      fail 'Quoted $* joins args' "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'set -- a "b c" d; for x in "$@"; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a "b c" d; for x in "$@"; do echo "[$x]"; done' 2>&1)
  expected=$(printf "[a]\n[b c]\n[d]")
  if [ "$result" = "$expected" ]; then
      pass 'Quoted $@ preserves quoting in original args'
  section "468. NESTED QUOTING"
  # =====================================
 -result=$("$FORTSH_BIN" -c "echo 'single \"with\" double'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'single \"with\" double'" 2>&1)
  if [ "$result" = 'single "with" double' ]; then
      pass "Double quotes inside single quotes"
  else
      fail "Double quotes inside single quotes"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "double '\''with'\'' single"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "double '\''with'\'' single"' 2>&1)
  if [ "$result" = "double 'with' single" ]; then
      pass "Single quotes inside double quotes (escaped)"
  else
  section "469. QUOTING IN ASSIGNMENTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="hello world"; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello world"; echo $x' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Quoted assignment with spaces"
  else
      fail "Quoted assignment with spaces" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "x='hello world'; echo \$x" 2>&1)
 +result=$("$SHELL_BIN" -c "x='hello world'; echo \$x" 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Single-quoted assignment with spaces"
  else
      fail "Single-quoted assignment with spaces" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=hello\ world; echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello\ world; echo $x' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Escaped space in assignment"
  else
  section "470. QUOTING IN COMMAND SUBSTITUTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=$(echo "hello world"); echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=$(echo "hello world"); echo "$x"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Quoted string in command substitution"
  else
      fail "Quoted string in command substitution" "hello world" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=`echo "hello world"`; echo "$x"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=`echo "hello world"`; echo "$x"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Quoted string in backtick substitution"
  else
  section "471. QUOTING AND GLOB PREVENTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "*"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "*"' 2>&1)
  if [ "$result" = "*" ]; then
      pass "Quoted asterisk is literal"
  else
      fail "Quoted asterisk is literal" "*" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "?"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "?"' 2>&1)
  if [ "$result" = "?" ]; then
      pass "Quoted question mark is literal"
  else
      fail "Quoted question mark is literal" "?" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "[abc]"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "[abc]"' 2>&1)
  if [ "$result" = "[abc]" ]; then
      pass "Quoted brackets are literal"
  else
  section "472. QUOTING IN TESTS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x=""; [ -z "$x" ] && echo empty' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; [ -z "$x" ] && echo empty' 2>&1)
  if [ "$result" = "empty" ]; then
      pass "Quoted empty var in test -z"
  else
      fail "Quoted empty var in test -z" "empty" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="hello"; [ -n "$x" ] && echo nonempty' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="hello"; [ -n "$x" ] && echo nonempty' 2>&1)
  if [ "$result" = "nonempty" ]; then
      pass "Quoted var in test -n"
  else
      fail "Quoted var in test -n" "nonempty" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a b"; [ "$x" = "a b" ] && echo match' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a b"; [ "$x" = "a b" ] && echo match' 2>&1)
  if [ "$result" = "match" ]; then
      pass "Quoted var with spaces in test ="
  else
  section "473. QUOTING IN CASE PATTERNS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'x="*"; case "$x" in "*") echo literal;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="*"; case "$x" in "*") echo literal;; esac' 2>&1)
  if [ "$result" = "literal" ]; then
      pass "Quoted asterisk matches literally in case"
  else
      fail "Quoted asterisk matches literally in case" "literal" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x="a b"; case "$x" in "a b") echo match;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="a b"; case "$x" in "a b") echo match;; esac' 2>&1)
  if [ "$result" = "match" ]; then
      pass "Quoted pattern with space in case"
  else
  section "474. QUOTING IN FUNCTION ARGS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'f() { echo "[$1]"; }; f "hello world"' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo "[$1]"; }; f "hello world"' 2>&1)
  if [ "$result" = "[hello world]" ]; then
      pass "Quoted arg to function"
  else
      fail "Quoted arg to function" "[hello world]" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'f() { echo $#; }; f "a b" "c d"' 2>&1)
 +result=$("$SHELL_BIN" -c 'f() { echo $#; }; f "a b" "c d"' 2>&1)
  if [ "$result" = "2" ]; then
      pass "Quoted args count in function"
  else
  section "475. DOLLAR IN QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "\$HOME"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "\$HOME"' 2>&1)
  if [ "$result" = '$HOME' ]; then
      pass "Escaped dollar in double quotes"
  else
      fail "Escaped dollar in double quotes" "\$HOME" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo '\$HOME'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo '\$HOME'" 2>&1)
  if [ "$result" = '$HOME' ]; then
      pass "Dollar in single quotes"
  else
  section "476. BACKSLASH IN QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "\\"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "\\"' 2>&1)
  if [ "$result" = '\' ]; then
      pass "Escaped backslash in double quotes"
  else
      fail "Escaped backslash in double quotes" "\\" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo '\\'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo '\\'" 2>&1)
  if [ "$result" = '\' ]; then
      pass "Backslash in single quotes"
  else
  section "477. QUOTE REMOVAL"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo ""hello""' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo ""hello""' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Empty quotes around word"
  else
      fail "Empty quotes around word" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "a""b""c"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "a""b""c"' 2>&1)
  if [ "$result" = "abc" ]; then
      pass "Adjacent quoted strings concatenate"
  else
  section "478. MIXED QUOTE STYLES"
  # =====================================
 -result=$("$FORTSH_BIN" -c "x=val; echo 'a'\"\$x\"'b'" 2>&1)
 +result=$("$SHELL_BIN" -c "x=val; echo 'a'\"\$x\"'b'" 2>&1)
  if [ "$result" = "avalb" ]; then
      pass "Mixed single and double quotes"
  else
      fail "Mixed single and double quotes" "avalb" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo 'single'\"double\"'single'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'single'\"double\"'single'" 2>&1)
  if [ "$result" = "singledoublesingle" ]; then
      pass "Alternating quote styles"
  else
  section "479. QUOTING IN REDIRECTIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo test > "/tmp/quote space test.txt"; cat "/tmp/quote space test.txt"; rm "/tmp/quote space test.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test > "/tmp/quote space test.txt"; cat "/tmp/quote space test.txt"; rm "/tmp/quote space test.txt"' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Quoted filename with space in redirect"
  else
  section "480. EMPTY QUOTES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo ""' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo ""' 2>&1)
  if [ -z "$result" ]; then
      pass "Empty double quotes produce empty output"
  else
      fail "Empty double quotes produce empty output" "empty" "$result"
  fi
 -result=$("$FORTSH_BIN" -c "echo ''" 2>&1)
 +result=$("$SHELL_BIN" -c "echo ''" 2>&1)
  if [ -z "$result" ]; then
      pass "Empty single quotes produce empty output"
  else
      fail "Empty single quotes produce empty output" "empty" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=""; echo "[$x]"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=""; echo "[$x]"' 2>&1)
  if [ "$result" = "[]" ]; then
      pass "Empty var in quotes"
  else

suites/posix/posix_compliance_redirect.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  section "428. OUTPUT REDIRECTION >"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello > '"$TEST_DIR"'/out1.txt; cat '"$TEST_DIR"'/out1.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello > '"$TEST_DIR"'/out1.txt; cat '"$TEST_DIR"'/out1.txt' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "> redirects stdout to file"
  else
      fail "> redirects stdout to file" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo first > '"$TEST_DIR"'/out2.txt; echo second > '"$TEST_DIR"'/out2.txt; cat '"$TEST_DIR"'/out2.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo first > '"$TEST_DIR"'/out2.txt; echo second > '"$TEST_DIR"'/out2.txt; cat '"$TEST_DIR"'/out2.txt' 2>&1)
  if [ "$result" = "second" ]; then
      pass "> overwrites existing file"
  else
      fail "> overwrites existing file" "second" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "multi word" > '"$TEST_DIR"'/out3.txt; cat '"$TEST_DIR"'/out3.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "multi word" > '"$TEST_DIR"'/out3.txt; cat '"$TEST_DIR"'/out3.txt' 2>&1)
  if [ "$result" = "multi word" ]; then
      pass "> with quoted string"
  else
  section "429. APPEND REDIRECTION >>"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo first > '"$TEST_DIR"'/append.txt; echo second >> '"$TEST_DIR"'/append.txt; cat '"$TEST_DIR"'/append.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo first > '"$TEST_DIR"'/append.txt; echo second >> '"$TEST_DIR"'/append.txt; cat '"$TEST_DIR"'/append.txt' 2>&1)
  expected=$(printf "first\nsecond")
  if [ "$result" = "$expected" ]; then
      pass ">> appends to file"
      fail ">> appends to file" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo line1 >> '"$TEST_DIR"'/new.txt; cat '"$TEST_DIR"'/new.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo line1 >> '"$TEST_DIR"'/new.txt; cat '"$TEST_DIR"'/new.txt' 2>&1)
  if [ "$result" = "line1" ]; then
      pass ">> creates file if not exists"
  else
  echo "test input" > "$TEST_DIR/input.txt"
 -result=$("$FORTSH_BIN" -c 'cat < '"$TEST_DIR"'/input.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < '"$TEST_DIR"'/input.txt' 2>&1)
  if [ "$result" = "test input" ]; then
      pass "< redirects file to stdin"
  else
      fail "< redirects file to stdin" "test input" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'read line < '"$TEST_DIR"'/input.txt; echo "$line"' 2>&1)
 +result=$("$SHELL_BIN" -c 'read line < '"$TEST_DIR"'/input.txt; echo "$line"' 2>&1)
  if [ "$result" = "test input" ]; then
      pass "< with read builtin"
  else
  section "431. STDERR REDIRECTION 2>"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'ls /nonexistent 2> '"$TEST_DIR"'/err.txt; cat '"$TEST_DIR"'/err.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'ls /nonexistent 2> '"$TEST_DIR"'/err.txt; cat '"$TEST_DIR"'/err.txt' 2>&1)
  if echo "$result" | grep -qi "no such\|not found\|cannot"; then
      pass "2> redirects stderr to file"
  else
      fail "2> redirects stderr to file" "error message" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo stdout; ls /nonexistent 2>/dev/null' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo stdout; ls /nonexistent 2>/dev/null' 2>&1)
  if [ "$result" = "stdout" ]; then
      pass "2>/dev/null suppresses stderr"
  else
  section "432. REDIRECT STDERR TO STDOUT 2>&1"
  # =====================================
 -result=$("$FORTSH_BIN" -c '{ echo out; ls /nonexistent; } 2>&1 | head -2' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo out; ls /nonexistent; } 2>&1 | head -2' 2>&1)
  if echo "$result" | grep -q "out"; then
      pass "2>&1 merges stderr to stdout"
  else
      fail "2>&1 merges stderr to stdout" "both streams" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'ls /nonexistent 2>&1 | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'ls /nonexistent 2>&1 | cat' 2>&1)
  if echo "$result" | grep -qi "no such\|not found\|cannot"; then
      pass "2>&1 stderr goes through pipe"
  else
  section "433. REDIRECT STDOUT TO STDERR 1>&2"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo error >&2' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo error >&2' 2>&1)
  if [ "$result" = "error" ]; then
      pass ">&2 redirects stdout to stderr"
  else
  # Note: matches bash - POSIX redirections processed left-to-right
  # 1>&2 copies fd2 to fd1, then 2>/dev/null redirects fd2 to null
  # fd1 still points to original fd2 (stderr), so output appears
 -result=$("$FORTSH_BIN" -c 'echo error 1>&2 2>/dev/null' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo error 1>&2 2>/dev/null' 2>&1)
  if [ "$result" = "error" ]; then
      pass "1>&2 with stderr suppressed (matches bash)"
  else
  section "434. COMBINED REDIRECTIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo out > '"$TEST_DIR"'/combined.txt 2>&1; cat '"$TEST_DIR"'/combined.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo out > '"$TEST_DIR"'/combined.txt 2>&1; cat '"$TEST_DIR"'/combined.txt' 2>&1)
  if [ "$result" = "out" ]; then
      pass "> file 2>&1 combination"
  else
      fail "> file 2>&1 combination" "out" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '{ echo out; echo err >&2; } > '"$TEST_DIR"'/both.txt 2>&1; cat '"$TEST_DIR"'/both.txt' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo out; echo err >&2; } > '"$TEST_DIR"'/both.txt 2>&1; cat '"$TEST_DIR"'/both.txt' 2>&1)
  expected=$(printf "out\nerr")
  if [ "$result" = "$expected" ]; then
      pass "Both streams to same file"
  echo "original" > "$TEST_DIR/noclobber.txt"
 -result=$("$FORTSH_BIN" -c 'set -C; echo new >| '"$TEST_DIR"'/noclobber.txt; cat '"$TEST_DIR"'/noclobber.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -C; echo new >| '"$TEST_DIR"'/noclobber.txt; cat '"$TEST_DIR"'/noclobber.txt' 2>&1)
  if [ "$result" = "new" ]; then
      pass ">| overrides noclobber"
  else
  section "436. SIMPLE PIPELINE"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello | cat' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Simple two-stage pipeline"
  else
      fail "Simple two-stage pipeline" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo hello world | wc -w' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello world | wc -w' 2>&1)
  if echo "$result" | grep -q "2"; then
      pass "Pipeline with wc"
  else
      fail "Pipeline with wc" "2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "c\na\nb\n" | sort' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "c\na\nb\n" | sort' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "Pipeline with sort"
  section "437. MULTI-STAGE PIPELINE"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello | cat | cat | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello | cat | cat | cat' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Four-stage pipeline"
  else
      fail "Four-stage pipeline" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "b\na\nc\nb\na\n" | sort | uniq' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "b\na\nc\nb\na\n" | sort | uniq' 2>&1)
  expected=$(printf "a\nb\nc")
  if [ "$result" = "$expected" ]; then
      pass "sort | uniq pipeline"
      fail "sort | uniq pipeline" "$expected" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "hello world" | tr " " "\n" | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello world" | tr " " "\n" | wc -l' 2>&1)
  if echo "$result" | grep -q "2"; then
      pass "tr | wc pipeline"
  else
  section "438. PIPELINE WITH REDIRECTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello | cat > '"$TEST_DIR"'/pipe_out.txt; cat '"$TEST_DIR"'/pipe_out.txt' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello | cat > '"$TEST_DIR"'/pipe_out.txt; cat '"$TEST_DIR"'/pipe_out.txt' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Pipeline with output redirect"
  else
  fi
  echo "from file" > "$TEST_DIR/pipe_in.txt"
 -result=$("$FORTSH_BIN" -c 'cat < '"$TEST_DIR"'/pipe_in.txt | tr "a-z" "A-Z"' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < '"$TEST_DIR"'/pipe_in.txt | tr "a-z" "A-Z"' 2>&1)
  if [ "$result" = "FROM FILE" ]; then
      pass "Input redirect into pipeline"
  else
  section "439. PIPELINE SUBSHELL"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo test | { read x; echo "got: $x"; }' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test | { read x; echo "got: $x"; }' 2>&1)
  if [ "$result" = "got: test" ]; then
      pass "Pipeline to brace group"
  else
      fail "Pipeline to brace group" "got: test" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo test | (cat; echo done)' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test | (cat; echo done)' 2>&1)
  expected=$(printf "test\ndone")
  if [ "$result" = "$expected" ]; then
      pass "Pipeline to subshell"
  section "440. COMMAND SUBSTITUTION IN PIPELINE"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo $(echo hello | tr "a-z" "A-Z")' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(echo hello | tr "a-z" "A-Z")' 2>&1)
  if [ "$result" = "HELLO" ]; then
      pass "Command substitution with pipeline"
  else
      fail "Command substitution with pipeline" "HELLO" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'x=$(printf "a\nb\nc\n" | wc -l); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=$(printf "a\nb\nc\n" | wc -l); echo $x' 2>&1)
  if echo "$result" | grep -q "3"; then
      pass "Variable from pipeline in command sub"
  else
  # =====================================
  # The order matters: 2>&1 before > vs after
 -result=$("$FORTSH_BIN" -c '{ echo out; echo err >&2; } > '"$TEST_DIR"'/order1.txt 2>&1; cat '"$TEST_DIR"'/order1.txt | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo out; echo err >&2; } > '"$TEST_DIR"'/order1.txt 2>&1; cat '"$TEST_DIR"'/order1.txt | wc -l' 2>&1)
  if echo "$result" | grep -q "2"; then
      pass "> file 2>&1 captures both"
  else
  section "442. /dev/null REDIRECTION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello > /dev/null; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello > /dev/null; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "> /dev/null discards output"
  else
      fail "> /dev/null discards output" "done" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'cat < /dev/null; echo empty' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < /dev/null; echo empty' 2>&1)
  if [ "$result" = "empty" ]; then
      pass "< /dev/null provides empty input"
  else
      fail "< /dev/null provides empty input" "empty" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'ls /nonexistent 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'ls /nonexistent 2>/dev/null; echo $?' 2>&1)
  # Should show non-zero exit but no error output
  if echo "$result" | grep -qE "^[12]$"; then
      pass "2>/dev/null with failing command"
  # =====================================
  # Note: <() is a bash extension, but we test if basic redirects work with commands
 -result=$("$FORTSH_BIN" -c 'diff <(echo a) <(echo a) 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'diff <(echo a) <(echo a) 2>/dev/null; echo $?' 2>&1)
  # This may not be supported - just document if it works
  if [ "$result" = "0" ]; then
      pass "Process substitution <() works"
  section "444. CLOSING FILE DESCRIPTORS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo hello >&-; echo done 2>/dev/null' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello >&-; echo done 2>/dev/null' 2>&1)
  # Closing stdout then trying to echo should either error or succeed
  if echo "$result" | grep -q "done"; then
      pass ">&- closes stdout (recovered)"
  section "445. DUPLICATING INPUT"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo test | { cat; } 0<&0' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test | { cat; } 0<&0' 2>&1)
  if [ "$result" = "test" ]; then
      pass "0<&0 duplicates stdin"
  else
  # =====================================
  # Last command determines exit status
 -result=$("$FORTSH_BIN" -c 'false | true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'false | true; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "Pipeline exit is last command (false|true=0)"
  else
      fail "Pipeline exit is last command (false|true=0)" "0" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'true | false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'true | false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Pipeline exit is last command (true|false=1)"
  else
  fi
  # Multi-stage pipeline
 -result=$("$FORTSH_BIN" -c 'echo a | cat | cat | cat; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo a | cat | cat | cat; echo $?' 2>&1)
  if echo "$result" | grep -q "0"; then
      pass "Multi-stage pipeline success"
  else
  fi
  # Pipeline with negation
 -result=$("$FORTSH_BIN" -c '! false | true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '! false | true; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "! negates pipeline exit"
  else
  # =====================================
  # exec without command modifies shell FDs
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  exec 3>"'"$TEST_DIR"'/exec_fd3.txt"
  echo "fd3 data" >&3
  exec 3>&-
  fi
  # exec read/write mode
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  echo "initial" > "'"$TEST_DIR"'/rw_test.txt"
  exec 4<>"'"$TEST_DIR"'/rw_test.txt"
  read line <&4
  # =====================================
  # Redirect entire loop
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2 3; do
      echo $i
  done > "'"$TEST_DIR"'/loop_out.txt"
  fi
  # Redirect if statement
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  if true; then
      echo inside
  fi > "'"$TEST_DIR"'/if_out.txt"
  fi
  # Redirect case statement
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  case "x" in
      x) echo matched;;
  esac > "'"$TEST_DIR"'/case_out.txt"
  # cat multiple files
  echo "file1" > "$TEST_DIR/cat1.txt"
  echo "file2" > "$TEST_DIR/cat2.txt"
 -result=$("$FORTSH_BIN" -c 'cat "'"$TEST_DIR"'/cat1.txt" "'"$TEST_DIR"'/cat2.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat "'"$TEST_DIR"'/cat1.txt" "'"$TEST_DIR"'/cat2.txt"' 2>&1)
  expected=$(printf "file1\nfile2")
  if [ "$result" = "$expected" ]; then
      pass "cat multiple files"
  # Input from file
  echo "from file" > "$TEST_DIR/input.txt"
 -result=$("$FORTSH_BIN" -c 'cat < "'"$TEST_DIR"'/input.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < "'"$TEST_DIR"'/input.txt"' 2>&1)
  if [ "$result" = "from file" ]; then
      pass "< redirects stdin from file"
  else
  # >> creates file if not exists
  rm -f "$TEST_DIR/append_new.txt"
 -result=$("$FORTSH_BIN" -c 'echo first >> "'"$TEST_DIR"'/append_new.txt"; cat "'"$TEST_DIR"'/append_new.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo first >> "'"$TEST_DIR"'/append_new.txt"; cat "'"$TEST_DIR"'/append_new.txt"' 2>&1)
  if [ "$result" = "first" ]; then
      pass ">> creates file if not exists"
  else
  # >> appends to existing
  echo "line1" > "$TEST_DIR/append_exist.txt"
 -result=$("$FORTSH_BIN" -c 'echo line2 >> "'"$TEST_DIR"'/append_exist.txt"; cat "'"$TEST_DIR"'/append_exist.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo line2 >> "'"$TEST_DIR"'/append_exist.txt"; cat "'"$TEST_DIR"'/append_exist.txt"' 2>&1)
  expected=$(printf "line1\nline2")
  if [ "$result" = "$expected" ]; then
      pass ">> appends to existing file"
  # Multiple appends
  rm -f "$TEST_DIR/multi_append.txt"
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  echo a >> "'"$TEST_DIR"'/multi_append.txt"
  echo b >> "'"$TEST_DIR"'/multi_append.txt"
  echo c >> "'"$TEST_DIR"'/multi_append.txt"
  # =====================================
  # Assignment with redirect
 -result=$("$FORTSH_BIN" -c 'x=$(cat < /dev/null); echo "empty:[$x]"' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=$(cat < /dev/null); echo "empty:[$x]"' 2>&1)
  if [ "$result" = "empty:[]" ]; then
      pass "Assignment from empty file"
  else
  fi
  # Assignment captures command output despite redirects
 -result=$("$FORTSH_BIN" -c 'x=$(echo hello 2>/dev/null); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=$(echo hello 2>/dev/null); echo $x' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Assignment captures stdout"
  else
  # =====================================
  # Basic heredoc
 -result=$("$FORTSH_BIN" -c 'cat <<END
 +result=$("$SHELL_BIN" -c 'cat <<END
  hello
  END' 2>&1)
  if [ "$result" = "hello" ]; then
  fi
  # Heredoc with variable expansion
 -result=$("$FORTSH_BIN" -c 'X=world; cat <<END
 +result=$("$SHELL_BIN" -c 'X=world; cat <<END
  hello $X
  END' 2>&1)
  if [ "$result" = "hello world" ]; then
  fi
  # Quoted heredoc prevents expansion
 -result=$("$FORTSH_BIN" -c 'cat <<'\''END'\''
 +result=$("$SHELL_BIN" -c 'cat <<'\''END'\''
  $VAR
  END' 2>&1)
  if [ "$result" = '$VAR' ]; then
  # =====================================
  # Long pipeline
 -result=$("$FORTSH_BIN" -c 'echo test | cat | cat | cat | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test | cat | cat | cat | cat' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Long pipeline with multiple cats"
  else
  fi
  # Pipeline with head
 -result=$("$FORTSH_BIN" -c 'printf "a\nb\nc\n" | head -1' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "a\nb\nc\n" | head -1' 2>&1)
  if [ "$result" = "a" ]; then
      pass "Pipeline with head"
  else
  fi
  # Pipeline with tail
 -result=$("$FORTSH_BIN" -c 'printf "a\nb\nc\n" | tail -1' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "a\nb\nc\n" | tail -1' 2>&1)
  if [ "$result" = "c" ]; then
      pass "Pipeline with tail"
  else
  fi
  # Pipeline with sort
 -result=$("$FORTSH_BIN" -c 'printf "c\na\nb\n" | sort | head -1' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "c\na\nb\n" | sort | head -1' 2>&1)
  if [ "$result" = "a" ]; then
      pass "Pipeline with sort"
  else
  # =====================================
  # Dup stdout to stderr
 -result=$("$FORTSH_BIN" -c 'echo test >&2' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test >&2' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Redirect stdout to stderr"
  else
  # Close stdout after redirecting to stderr
  # Note: matches bash - >&2 redirects stdout to stderr, then 1>&- closes fd1
  # The write to closed fd1 fails with "Bad file descriptor"
 -result=$("$FORTSH_BIN" -c 'echo test >&2 1>&-' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test >&2 1>&-' 2>&1)
  if echo "$result" | grep -q "Bad file descriptor"; then
      pass "Close stdout after redirect (matches bash - write error)"
  else
  # Input from file
  echo "content" > "$TEST_DIR/input_test.txt"
 -result=$("$FORTSH_BIN" -c 'cat < "'"$TEST_DIR"'/input_test.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < "'"$TEST_DIR"'/input_test.txt"' 2>&1)
  if [ "$result" = "content" ]; then
      pass "Input redirection from file"
  else
  fi
  # Input from /dev/null
 -result=$("$FORTSH_BIN" -c 'cat < /dev/null | wc -c' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < /dev/null | wc -c' 2>&1)
  if [ "$result" -eq 0 ] 2>/dev/null; then
      pass "Input from /dev/null is empty"
  else
  # =====================================
  # Stdout to /dev/null
 -result=$("$FORTSH_BIN" -c 'echo hidden > /dev/null; echo visible' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hidden > /dev/null; echo visible' 2>&1)
  if [ "$result" = "visible" ]; then
      pass "Stdout to /dev/null suppresses output"
  else
  fi
  # Stderr to /dev/null
 -result=$("$FORTSH_BIN" -c 'ls /nonexistent 2>/dev/null; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'ls /nonexistent 2>/dev/null; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "Stderr to /dev/null suppresses errors"
  else
  fi
  # Both to /dev/null
 -result=$("$FORTSH_BIN" -c 'ls /nonexistent >/dev/null 2>&1; echo status=$?' 2>&1)
 +result=$("$SHELL_BIN" -c 'ls /nonexistent >/dev/null 2>&1; echo status=$?' 2>&1)
  if echo "$result" | grep -q "status="; then
      pass "Both stdout and stderr to /dev/null"
  else
  # Normal overwrite
  echo "old" > "$TEST_DIR/clobber_test.txt"
 -result=$("$FORTSH_BIN" -c 'echo new > "'"$TEST_DIR"'/clobber_test.txt"; cat "'"$TEST_DIR"'/clobber_test.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo new > "'"$TEST_DIR"'/clobber_test.txt"; cat "'"$TEST_DIR"'/clobber_test.txt"' 2>&1)
  if [ "$result" = "new" ]; then
      pass "Normal > overwrites file"
  else
  # =====================================
  # Redirect in if statement
 -result=$("$FORTSH_BIN" -c 'if true; then echo yes; fi > "'"$TEST_DIR"'/if_redir.txt"; cat "'"$TEST_DIR"'/if_redir.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'if true; then echo yes; fi > "'"$TEST_DIR"'/if_redir.txt"; cat "'"$TEST_DIR"'/if_redir.txt"' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "Redirect if statement output"
  else
  fi
  # Redirect in while loop
 -result=$("$FORTSH_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done > "'"$TEST_DIR"'/while_redir.txt"; wc -l < "'"$TEST_DIR"'/while_redir.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done > "'"$TEST_DIR"'/while_redir.txt"; wc -l < "'"$TEST_DIR"'/while_redir.txt"' 2>&1)
  if [ "$result" -eq 3 ] 2>/dev/null; then
      pass "Redirect while loop output"
  else
  fi
  # Redirect in for loop
 -result=$("$FORTSH_BIN" -c 'for x in a b c; do echo $x; done > "'"$TEST_DIR"'/for_redir.txt"; wc -l < "'"$TEST_DIR"'/for_redir.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'for x in a b c; do echo $x; done > "'"$TEST_DIR"'/for_redir.txt"; wc -l < "'"$TEST_DIR"'/for_redir.txt"' 2>&1)
  if [ "$result" -eq 3 ] 2>/dev/null; then
      pass "Redirect for loop output"
  else
  # =====================================
  # Last command determines exit
 -result=$("$FORTSH_BIN" -c 'true | false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'true | false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Pipeline exit from last command (false)"
  else
      fail "Pipeline exit from last command (false)" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'false | true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'false | true; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass "Pipeline exit from last command (true)"
  else
  # Both input and output
  echo "input" > "$TEST_DIR/multi_in.txt"
 -result=$("$FORTSH_BIN" -c 'cat < "'"$TEST_DIR"'/multi_in.txt" > "'"$TEST_DIR"'/multi_out.txt"; cat "'"$TEST_DIR"'/multi_out.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'cat < "'"$TEST_DIR"'/multi_in.txt" > "'"$TEST_DIR"'/multi_out.txt"; cat "'"$TEST_DIR"'/multi_out.txt"' 2>&1)
  if [ "$result" = "input" ]; then
      pass "Both input and output redirect"
  else
  fi
  # Order of redirections
 -result=$("$FORTSH_BIN" -c 'echo test > "'"$TEST_DIR"'/order1.txt" 2>&1; cat "'"$TEST_DIR"'/order1.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test > "'"$TEST_DIR"'/order1.txt" 2>&1; cat "'"$TEST_DIR"'/order1.txt"' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Redirect order: > then 2>&1"
  else
  # =====================================
  # Subshell in pipeline
 -result=$("$FORTSH_BIN" -c '(echo a; echo b) | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '(echo a; echo b) | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "Subshell in pipeline"
  else
  fi
  # Brace group in pipeline
 -result=$("$FORTSH_BIN" -c '{ echo x; echo y; } | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo x; echo y; } | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "Brace group in pipeline"
  else
  # =====================================
  # Pipeline with final redirect
 -result=$("$FORTSH_BIN" -c 'echo test | cat > "'"$TEST_DIR"'/pipe_redir.txt"; cat "'"$TEST_DIR"'/pipe_redir.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test | cat > "'"$TEST_DIR"'/pipe_redir.txt"; cat "'"$TEST_DIR"'/pipe_redir.txt"' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Pipeline with final redirect"
  else
  fi
  # Redirect within pipeline
 -result=$("$FORTSH_BIN" -c 'echo test 2>/dev/null | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test 2>/dev/null | cat' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Redirect within pipeline stage"
  else
  # =====================================
  # Echo pipe as here-string alternative
 -result=$("$FORTSH_BIN" -c 'echo "test" | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "test" | cat' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Echo pipe as here-string alternative"
  else
  fi
  # Printf pipe
 -result=$("$FORTSH_BIN" -c 'printf "%s" "test" | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "%s" "test" | cat' 2>&1)
  if [ "$result" = "test" ]; then
      pass "Printf pipe"
  else
  # =====================================
  # Redirect to same file
 -result=$("$FORTSH_BIN" -c 'echo original > "'"$TEST_DIR"'/same.txt"; echo new > "'"$TEST_DIR"'/same.txt"; cat "'"$TEST_DIR"'/same.txt"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo original > "'"$TEST_DIR"'/same.txt"; echo new > "'"$TEST_DIR"'/same.txt"; cat "'"$TEST_DIR"'/same.txt"' 2>&1)
  if [ "$result" = "new" ]; then
      pass "Multiple redirects to same file"
  else
  # Empty redirect (creates empty file)
  rm -f "$TEST_DIR/empty_redir.txt"
 -result=$("$FORTSH_BIN" -c '> "'"$TEST_DIR"'/empty_redir.txt"; [ -f "'"$TEST_DIR"'/empty_redir.txt" ] && echo exists' 2>&1)
 +result=$("$SHELL_BIN" -c '> "'"$TEST_DIR"'/empty_redir.txt"; [ -f "'"$TEST_DIR"'/empty_redir.txt" ] && echo exists' 2>&1)
  if [ "$result" = "exists" ]; then
      pass "Empty redirect creates file"
  else
  # =====================================
  # Pipeline preserves data integrity
 -result=$("$FORTSH_BIN" -c 'echo "hello world" | cat | cat | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello world" | cat | cat | cat' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "Pipeline preserves data integrity"
  else
  fi
  # Multiple pipes with tr
 -result=$("$FORTSH_BIN" -c 'echo abc | tr a X | tr b Y | tr c Z' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo abc | tr a X | tr b Y | tr c Z' 2>&1)
  if [ "$result" = "XYZ" ]; then
      pass "Multiple pipes with tr"
  else

suites/posix/posix_compliance_special.shmodified

1116 lines changed — click to load

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  # =====================================
  # LINENO in simple script
 -result=$("$FORTSH_BIN" -c 'echo $LINENO' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $LINENO' 2>&1)
  if [ "$result" = "1" ]; then
      pass "LINENO is 1 on first line"
  else
  fi
  # LINENO increments
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  echo $LINENO
  echo $LINENO
  echo $LINENO
  fi
  # LINENO in function
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  func() {
      echo $LINENO
+ }
  # =====================================
  # PPID is set
 -result=$("$FORTSH_BIN" -c 'echo $PPID' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $PPID' 2>&1)
  if [ -n "$result" ] && [ "$result" -gt 0 ] 2>/dev/null; then
      pass "PPID is set to positive number"
  else
  # PPID matches parent
  parent_pid=$$
 -result=$("$FORTSH_BIN" -c 'echo $PPID' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $PPID' 2>&1)
  # PPID should be reasonable (not 0 or 1 unless running as init)
  if [ "$result" -gt 1 ] 2>/dev/null; then
      pass "PPID is reasonable value"
  fi
  # PPID is readonly conceptually (cannot be assigned)
 -result=$("$FORTSH_BIN" -c 'PPID=999; echo $PPID' 2>&1)
 +result=$("$SHELL_BIN" -c 'PPID=999; echo $PPID' 2>&1)
  if [ "$result" != "999" ]; then
      pass "PPID cannot be overwritten"
  else
  # =====================================
  # FD 3 redirect out
 -result=$("$FORTSH_BIN" -c 'echo hello 3>/tmp/fd3test_$$; cat /tmp/fd3test_$$; rm -f /tmp/fd3test_$$' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo hello 3>/tmp/fd3test_$$; cat /tmp/fd3test_$$; rm -f /tmp/fd3test_$$' 2>&1)
  # This might not output to fd3 without explicit redirect
  pass "FD 3 redirect syntax accepted"
  # FD 3 redirect with exec
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  exec 3>/tmp/fd3exec_$$
  echo "fd3 output" >&3
  exec 3>&-
  fi
  # FD 4 usage
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  exec 4>/tmp/fd4test_$$
  echo "fd4 data" >&4
  exec 4>&-
  fi
  # Multiple FDs
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  exec 3>/tmp/fd3m_$$ 4>/tmp/fd4m_$$
  echo "three" >&3
  echo "four" >&4
  # =====================================
  # Colon is no-op, returns 0
 -result=$("$FORTSH_BIN" -c ':; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c ':; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass ": returns exit status 0"
  else
  fi
  # Colon with arguments (ignored)
 -result=$("$FORTSH_BIN" -c ': arg1 arg2 arg3; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c ': arg1 arg2 arg3; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass ": ignores arguments"
  else
  fi
  # Colon with variable expansion (expansion happens but result ignored)
 -result=$("$FORTSH_BIN" -c 'x=1; : $((x=x+1)); echo $x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=1; : $((x=x+1)); echo $x' 2>&1)
  if [ "$result" = "2" ]; then
      pass ": performs expansions but ignores result"
  else
  fi
  # Colon in conditional
 -result=$("$FORTSH_BIN" -c 'if :; then echo yes; fi' 2>&1)
 +result=$("$SHELL_BIN" -c 'if :; then echo yes; fi' 2>&1)
  if [ "$result" = "yes" ]; then
      pass ": works in if condition"
  else
  fi
  # Colon in while (infinite loop prevention test)
 -result=$("$FORTSH_BIN" -c 'n=0; while :; do n=$((n+1)); [ $n -ge 3 ] && break; done; echo $n' 2>&1)
 +result=$("$SHELL_BIN" -c 'n=0; while :; do n=$((n+1)); [ $n -ge 3 ] && break; done; echo $n' 2>&1)
  if [ "$result" = "3" ]; then
      pass ": works in while loop"
  else
  # =====================================
  # Nested subshells
 -result=$("$FORTSH_BIN" -c 'echo $(echo $(echo deep))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(echo $(echo deep))' 2>&1)
  if [ "$result" = "deep" ]; then
      pass "Triple nested command substitution"
  else
  fi
  # Nested braces
 -result=$("$FORTSH_BIN" -c '{ { { echo nested; }; }; }' 2>&1)
 +result=$("$SHELL_BIN" -c '{ { { echo nested; }; }; }' 2>&1)
  if [ "$result" = "nested" ]; then
      pass "Triple nested brace groups"
  else
  fi
  # Mixed nesting
 -result=$("$FORTSH_BIN" -c '{ x=$(echo inner); echo $x; }' 2>&1)
 +result=$("$SHELL_BIN" -c '{ x=$(echo inner); echo $x; }' 2>&1)
  if [ "$result" = "inner" ]; then
      pass "Command substitution in brace group"
  else
  fi
  # Nested loops
 -result=$("$FORTSH_BIN" -c '
 +result=$("$SHELL_BIN" -c '
  for i in 1 2; do
      for j in a b; do
          echo "$i$j"
  # =====================================
  # Nested parameter expansion
 -result=$("$FORTSH_BIN" -c 'x=hello; y=${x:-${z:-default}}; echo $y' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello; y=${x:-${z:-default}}; echo $y' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "Nested default expansion (first set)"
  else
      fail "Nested default expansion (first set)" "hello" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'unset x; y=${x:-${z:-default}}; echo $y' 2>&1)
 +result=$("$SHELL_BIN" -c 'unset x; y=${x:-${z:-default}}; echo $y' 2>&1)
  if [ "$result" = "default" ]; then
      pass "Nested default expansion (fallback to nested)"
  else
  fi
  # Length of expansion result
 -result=$("$FORTSH_BIN" -c 'x=hello; echo ${#x}' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello; echo ${#x}' 2>&1)
  if [ "$result" = "5" ]; then
      pass "Length of variable"
  else
  fi
  # Pattern removal chained
 -result=$("$FORTSH_BIN" -c 'x="/path/to/file.txt"; y=${x##*/}; z=${y%.*}; echo $z' 2>&1)
 +result=$("$SHELL_BIN" -c 'x="/path/to/file.txt"; y=${x##*/}; z=${y%.*}; echo $z' 2>&1)
  if [ "$result" = "file" ]; then
      pass "Chained pattern removal"
  else
  # =====================================
  # Expansion in here-document
 -result=$("$FORTSH_BIN" -c 'x=VALUE; cat <<EOF
 +result=$("$SHELL_BIN" -c 'x=VALUE; cat <<EOF
  $x
  EOF' 2>&1)
  if [ "$result" = "VALUE" ]; then
  fi
  # No expansion in quoted heredoc
 -result=$("$FORTSH_BIN" -c "x=VALUE; cat <<'EOF'
 +result=$("$SHELL_BIN" -c "x=VALUE; cat <<'EOF'
  \$x
  EOF" 2>&1)
  if [ "$result" = '$x' ]; then
  fi
  # Expansion in case pattern
 -result=$("$FORTSH_BIN" -c 'pat="hel*"; case "hello" in $pat) echo match;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'pat="hel*"; case "hello" in $pat) echo match;; esac' 2>&1)
  if [ "$result" = "match" ]; then
      pass "Variable expansion in case pattern"
  else
  # =====================================
  # Unary minus
 -result=$("$FORTSH_BIN" -c 'echo $((-5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((-5))' 2>&1)
  if [ "$result" = "-5" ]; then
      pass "Unary minus in arithmetic"
  else
  fi
  # Unary plus
 -result=$("$FORTSH_BIN" -c 'echo $((+5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((+5))' 2>&1)
  if [ "$result" = "5" ]; then
      pass "Unary plus in arithmetic"
  else
  fi
  # Logical NOT
 -result=$("$FORTSH_BIN" -c 'echo $((!0))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((!0))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Logical NOT of 0"
  else
      fail "Logical NOT of 0" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((!1))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((!1))' 2>&1)
  if [ "$result" = "0" ]; then
      pass "Logical NOT of 1"
  else
  fi
  # Bitwise NOT
 -result=$("$FORTSH_BIN" -c 'echo $((~0))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((~0))' 2>&1)
  if [ "$result" = "-1" ]; then
      pass "Bitwise NOT of 0"
  else
  fi
  # Complex expression
 -result=$("$FORTSH_BIN" -c 'echo $(( (2 + 3) * 4 - 1 ))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(( (2 + 3) * 4 - 1 ))' 2>&1)
  if [ "$result" = "19" ]; then
      pass "Complex arithmetic with parens"
  else
  # =====================================
  # trap with signal name
 -result=$("$FORTSH_BIN" -c 'trap "echo caught" INT; trap' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo caught" INT; trap' 2>&1)
  if echo "$result" | grep -qE "INT|SIGINT"; then
      pass "trap accepts signal name"
  else
  fi
  # trap with signal number
 -result=$("$FORTSH_BIN" -c 'trap "echo caught" 2; trap' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo caught" 2; trap' 2>&1)
  if echo "$result" | grep -qE "INT|SIGINT|2"; then
      pass "trap accepts signal number"
  else
  fi
  # Multiple signals
 -result=$("$FORTSH_BIN" -c 'trap "echo exit" EXIT; trap "echo int" INT; trap' 2>&1)
 +result=$("$SHELL_BIN" -c 'trap "echo exit" EXIT; trap "echo int" INT; trap' 2>&1)
  if echo "$result" | grep -qE "EXIT|exit" && echo "$result" | grep -qE "INT|SIGINT"; then
      pass "trap with multiple signals"
  else
  # =====================================
  # Single quotes preserve everything
 -result=$("$FORTSH_BIN" -c "echo 'hello\nworld'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo 'hello\nworld'" 2>&1)
  if [ "$result" = 'hello\nworld' ]; then
      pass "Single quotes preserve backslash-n literally"
  else
  fi
  # Empty string quoting
 -result=$("$FORTSH_BIN" -c 'echo "" | wc -c' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "" | wc -c' 2>&1)
  # Empty string should produce just newline from echo
  result_trimmed=$(echo "$result" | tr -d ' ')
  if [ "$result_trimmed" = "1" ]; then
  fi
  # Quote within quote
 -result=$("$FORTSH_BIN" -c "echo \"it'\"'\"'s\"" 2>&1)
 +result=$("$SHELL_BIN" -c "echo \"it'\"'\"'s\"" 2>&1)
  # This is tricky - mixing quote styles
  pass "Mixed quote styles accepted"
  # Escaped quote in double quotes
 -result=$("$FORTSH_BIN" -c 'echo "say \"hello\""' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "say \"hello\""' 2>&1)
  if [ "$result" = 'say "hello"' ]; then
      pass "Escaped quotes in double quotes"
  else
  # =====================================
  # Empty IFS prevents splitting
 -result=$("$FORTSH_BIN" -c 'IFS=""; x="a b c"; set -- $x; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=""; x="a b c"; set -- $x; echo $#' 2>&1)
  if [ "$result" = "1" ]; then
      pass "Empty IFS prevents word splitting"
  else
  fi
  # IFS with multiple characters
 -result=$("$FORTSH_BIN" -c 'IFS=":,"; x="a:b,c"; set -- $x; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=":,"; x="a:b,c"; set -- $x; echo $#' 2>&1)
  if [ "$result" = "3" ]; then
      pass "IFS with multiple delimiters"
  else
  fi
  # Default IFS restoration
 -result=$("$FORTSH_BIN" -c 'IFS=":"; x="a:b"; set -- $x; unset IFS; y="c d"; set -- $y; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=":"; x="a:b"; set -- $x; unset IFS; y="c d"; set -- $y; echo $#' 2>&1)
  if [ "$result" = "2" ]; then
      pass "unset IFS restores default splitting"
  else
  # $$ in subshell should return parent shell PID per POSIX
  # Test within SAME shell instance (not separate invocations)
 -result=$("$FORTSH_BIN" -c 'echo $$; (echo $$)' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $$; (echo $$)' 2>&1)
  parent_pid=$(echo "$result" | sed -n '1p')
  subshell_pid=$(echo "$result" | sed -n '2p')
  if [ "$parent_pid" = "$subshell_pid" ]; then
  fi
  # $$ in command substitution
 -result=$("$FORTSH_BIN" -c 'echo $$ $(echo $$)' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $$ $(echo $$)' 2>&1)
  # Both should be the same PID
  pid1=$(echo "$result" | awk '{print $1}')
  pid2=$(echo "$result" | awk '{print $2}')
  fi
  # $$ is numeric
 -result=$("$FORTSH_BIN" -c 'echo $$' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $$' 2>&1)
  if [ "$result" -gt 0 ] 2>/dev/null; then
      pass "\$\$ is positive integer"
  else
  # =====================================
  # $@ preserves separate arguments
 -result=$("$FORTSH_BIN" -c 'set -- "a b" "c d"; for x in "$@"; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- "a b" "c d"; for x in "$@"; do echo "[$x]"; done' 2>&1)
  expected=$(printf "[a b]\n[c d]")
  if [ "$result" = "$expected" ]; then
      pass '"\$@" preserves argument boundaries'
  fi
  # $* joins with IFS
 -result=$("$FORTSH_BIN" -c 'IFS=":"; set -- a b c; echo "$*"' 2>&1)
 +result=$("$SHELL_BIN" -c 'IFS=":"; set -- a b c; echo "$*"' 2>&1)
  if [ "$result" = "a:b:c" ]; then
      pass '"\$*" joins with first char of IFS'
  else
  fi
  # $@ unquoted splits
 -result=$("$FORTSH_BIN" -c 'set -- "a b" "c d"; for x in $@; do echo "[$x]"; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- "a b" "c d"; for x in $@; do echo "[$x]"; done' 2>&1)
  # Should split into 4 words: a, b, c, d
  expected=$(printf "[a]\n[b]\n[c]\n[d]")
  if [ "$result" = "$expected" ]; then
  fi
  # Empty $@ produces nothing
 -result=$("$FORTSH_BIN" -c 'set --; for x in "$@"; do echo X; done; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'set --; for x in "$@"; do echo X; done; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass 'Empty "$@" produces no iterations'
  else
  fi
  # $# count
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; echo $#' 2>&1)
  if [ "$result" = "5" ]; then
      pass '$# counts positional parameters'
  else
  # =====================================
  # PWD is set
 -result=$("$FORTSH_BIN" -c 'echo $PWD' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $PWD' 2>&1)
  if [ -n "$result" ] && [ -d "$result" ]; then
      pass "PWD is set to valid directory"
  else
  fi
  # cd updates PWD
 -result=$("$FORTSH_BIN" -c 'cd /tmp && echo $PWD' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /tmp && echo $PWD' 2>&1)
  if echo "$result" | grep -q "tmp"; then
      pass "cd updates PWD"
  else
  fi
  # cd updates OLDPWD
 -result=$("$FORTSH_BIN" -c 'cd /; cd /tmp; echo $OLDPWD' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /; cd /tmp; echo $OLDPWD' 2>&1)
  if [ "$result" = "/" ]; then
      pass "cd updates OLDPWD"
  else
  fi
  # cd - uses OLDPWD
 -result=$("$FORTSH_BIN" -c 'cd /; cd /tmp; cd -' 2>&1)
 +result=$("$SHELL_BIN" -c 'cd /; cd /tmp; cd -' 2>&1)
  if echo "$result" | grep -q "/"; then
      pass "cd - prints previous directory"
  else
  # =====================================
  # $? after successful command
 -result=$("$FORTSH_BIN" -c 'true; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'true; echo $?' 2>&1)
  if [ "$result" = "0" ]; then
      pass '$? is 0 after true'
  else
  fi
  # $? after failed command
 -result=$("$FORTSH_BIN" -c 'false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass '$? is 1 after false'
  else
  fi
  # $? after exit N
 -result=$("$FORTSH_BIN" -c '(exit 42); echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '(exit 42); echo $?' 2>&1)
  if [ "$result" = "42" ]; then
      pass '$? captures exit code from subshell'
  else
  fi
  # $? after signal (128+signal)
 -result=$("$FORTSH_BIN" -c 'sh -c "kill -9 \$\$" 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'sh -c "kill -9 \$\$" 2>/dev/null; echo $?' 2>&1)
  if [ "$result" -ge 128 ] 2>/dev/null; then
      pass '$? is 128+ after signal death'
  else
  fi
  # $? after command not found
 -result=$("$FORTSH_BIN" -c 'nonexistent_cmd_xyz_12345 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'nonexistent_cmd_xyz_12345 2>/dev/null; echo $?' 2>&1)
  if [ "$result" = "127" ]; then
      pass '$? is 127 for command not found'
  else
  # =====================================
  # $0 in -c command
 -result=$("$FORTSH_BIN" -c 'echo $0' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $0' 2>&1)
  if [ -n "$result" ]; then
      pass '$0 is set in -c command'
  else
  fi
  # $0 can be set with -c
 -result=$("$FORTSH_BIN" -c 'echo $0' myname 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $0' myname 2>&1)
  if [ "$result" = "myname" ]; then
      pass '$0 can be set via argument after -c'
  else
  # =====================================
  # shift removes first positional param
 -result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c; shift; echo $1' 2>&1)
  if [ "$result" = "b" ]; then
      pass 'shift removes first parameter'
  else
  fi
  # shift N removes N params
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 2; echo $1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; shift 2; echo $1' 2>&1)
  if [ "$result" = "c" ]; then
      pass 'shift N removes N parameters'
  else
  fi
  # shift updates $#
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 3; echo $#' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; shift 3; echo $#' 2>&1)
  if [ "$result" = "2" ]; then
      pass 'shift updates $#'
  else
  fi
  # shift more than $# fails
 -result=$("$FORTSH_BIN" -c 'set -- a b; shift 5 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b; shift 5 2>/dev/null; echo $?' 2>&1)
  if [ "$result" != "0" ]; then
      pass 'shift beyond $# returns non-zero'
  else
  # =====================================
  # HOME is set
 -result=$("$FORTSH_BIN" -c 'echo $HOME' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $HOME' 2>&1)
  if [ -n "$result" ] && [ -d "$result" ]; then
      pass "HOME is set to valid directory"
  else
  fi
  # PATH is set
 -result=$("$FORTSH_BIN" -c 'echo $PATH' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $PATH' 2>&1)
  if [ -n "$result" ]; then
      pass "PATH is set"
  else
  # PATH affects command lookup - use actual system paths
  LS_DIR=$(dirname "$(which ls 2>/dev/null)")
 -result=$("$FORTSH_BIN" -c "PATH=$LS_DIR; ls / >/dev/null 2>&1; echo \$?" 2>&1)
 +result=$("$SHELL_BIN" -c "PATH=$LS_DIR; ls / >/dev/null 2>&1; echo \$?" 2>&1)
  if [ "$result" = "0" ]; then
      pass "PATH affects command resolution"
  else
  fi
  # Empty PATH means current directory only
 -result=$("$FORTSH_BIN" -c 'PATH=""; ls / 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'PATH=""; ls / 2>/dev/null; echo $?' 2>&1)
  if [ "$result" != "0" ]; then
      pass "Empty PATH prevents finding commands"
  else
  # =====================================
  # eval with variable containing command
 -result=$("$FORTSH_BIN" -c 'cmd="echo hello"; eval "$cmd"' 2>&1)
 +result=$("$SHELL_BIN" -c 'cmd="echo hello"; eval "$cmd"' 2>&1)
  if [ "$result" = "hello" ]; then
      pass "eval executes command in variable"
  else
  fi
  # eval with multiple arguments
 -result=$("$FORTSH_BIN" -c 'eval echo hello world' 2>&1)
 +result=$("$SHELL_BIN" -c 'eval echo hello world' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "eval concatenates arguments"
  else
  fi
  # eval with variable expansion
 -result=$("$FORTSH_BIN" -c 'x=y; y=z; eval echo \$$x' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=y; y=z; eval echo \$$x' 2>&1)
  if [ "$result" = "z" ]; then
      pass "eval performs double expansion"
  else
  fi
  # eval exit status
 -result=$("$FORTSH_BIN" -c 'eval false; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'eval false; echo $?' 2>&1)
  if [ "$result" = "1" ]; then
      pass "eval returns command exit status"
  else
  # =====================================
  # Command with -c flag
 -result=$("$FORTSH_BIN" -c 'echo test' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test' 2>&1)
  if [ "$result" = "test" ]; then
      pass "fortsh -c executes command"
  else
  fi
  # Command with environment var
 -result=$(X=value "$FORTSH_BIN" -c 'echo $X' 2>&1)
 +result=$(X=value "$SHELL_BIN" -c 'echo $X' 2>&1)
  if [ "$result" = "value" ]; then
      pass "env var passed to fortsh"
  else
  # =====================================
  # break outside loop
 -result=$("$FORTSH_BIN" -c 'break 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'break 2>/dev/null; echo $?' 2>&1)
  if echo "$result" | grep -qE '^[0-9]'; then
      pass "break outside loop returns error status"
  else
  fi
  # continue outside loop
 -result=$("$FORTSH_BIN" -c 'continue 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'continue 2>/dev/null; echo $?' 2>&1)
  if echo "$result" | grep -qE '^[0-9]'; then
      pass "continue outside loop returns error status"
  else
  fi
  # return outside function
 -result=$("$FORTSH_BIN" -c 'return 2>/dev/null; echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c 'return 2>/dev/null; echo $?' 2>&1)
  if echo "$result" | grep -qE '^[0-9]'; then
      pass "return outside function handled"
  else
  # =====================================
  # Redirect to /dev/null
 -result=$("$FORTSH_BIN" -c 'echo test > /dev/null; echo done' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test > /dev/null; echo done' 2>&1)
  if [ "$result" = "done" ]; then
      pass "redirect to /dev/null works"
  else
  fi
  # Redirect stderr to stdout
 -result=$("$FORTSH_BIN" -c 'echo stderr >&2' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo stderr >&2' 2>&1)
  if [ "$result" = "stderr" ]; then
      pass "redirect stderr to stdout"
  else
  # =====================================
  # More than 9 positional params
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e f g h i j k; echo $1 ${10} ${11}' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e f g h i j k; echo $1 ${10} ${11}' 2>&1)
  if echo "$result" | grep -q "a j k"; then
      pass "access to \${10} and beyond"
  else
  fi
  # shift with count
 -result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 3; echo $1' 2>&1)
 +result=$("$SHELL_BIN" -c 'set -- a b c d e; shift 3; echo $1' 2>&1)
  if [ "$result" = "d" ]; then
      pass "shift with count"
  else
  # =====================================
  # Negative numbers
 -result=$("$FORTSH_BIN" -c 'echo $((-5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((-5))' 2>&1)
  if [ "$result" = "-5" ]; then
      pass "negative numbers in arithmetic"
  else
  fi
  # Parentheses for grouping
 -result=$("$FORTSH_BIN" -c 'echo $(( (2+3) * 4 ))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(( (2+3) * 4 ))' 2>&1)
  if [ "$result" = "20" ]; then
      pass "parentheses in arithmetic"
  else
  fi
  # Comparison operators return 0/1
 -result=$("$FORTSH_BIN" -c 'echo $((5 > 3))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((5 > 3))' 2>&1)
  if [ "$result" = "1" ]; then
      pass "arithmetic comparison returns 1 for true"
  else
      fail "arithmetic comparison returns 1 for true" "1" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo $((3 > 5))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $((3 > 5))' 2>&1)
  if [ "$result" = "0" ]; then
      pass "arithmetic comparison returns 0 for false"
  else
  # =====================================
  # Assignment with empty value
 -result=$("$FORTSH_BIN" -c 'X=; echo "[$X]"' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=; echo "[$X]"' 2>&1)
  if [ "$result" = "[]" ]; then
      pass "empty variable assignment"
  else
  fi
  # Assignment with quotes
 -result=$("$FORTSH_BIN" -c 'X="hello world"; echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X="hello world"; echo $X' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "quoted variable assignment"
  else
  fi
  # Multiple assignments on one line
 -result=$("$FORTSH_BIN" -c 'A=1 B=2 C=3; echo $A $B $C' 2>&1)
 +result=$("$SHELL_BIN" -c 'A=1 B=2 C=3; echo $A $B $C' 2>&1)
  if [ "$result" = "1 2 3" ]; then
      pass "multiple assignments"
  else
  # =====================================
  # Single quotes preserve literally
 -result=$("$FORTSH_BIN" -c "echo '\$HOME'" 2>&1)
 +result=$("$SHELL_BIN" -c "echo '\$HOME'" 2>&1)
  if [ "$result" = '$HOME' ]; then
      pass "single quotes preserve dollar"
  else
  fi
  # Double quotes allow expansion
 -result=$("$FORTSH_BIN" -c 'X=test; echo "$X"' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=test; echo "$X"' 2>&1)
  if [ "$result" = "test" ]; then
      pass "double quotes allow expansion"
  else
  fi
  # Mixed quoting
 -result=$("$FORTSH_BIN" -c "X=val; echo 'literal'\"\$X\"'more'" 2>&1)
 +result=$("$SHELL_BIN" -c "X=val; echo 'literal'\"\$X\"'more'" 2>&1)
  if [ "$result" = "literalvalmore" ]; then
      pass "mixed quoting works"
  else
  # =====================================
  # Pipeline with three stages
 -result=$("$FORTSH_BIN" -c 'echo test | cat | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo test | cat | cat' 2>&1)
  if [ "$result" = "test" ]; then
      pass "three-stage pipeline"
  else
  fi
  # Pipeline with grep
 -result=$("$FORTSH_BIN" -c 'echo "hello world" | grep hello' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello world" | grep hello' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "pipeline with grep"
  else
  # =====================================
  # Case with wildcards
 -result=$("$FORTSH_BIN" -c 'x=hello; case $x in h*) echo match;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=hello; case $x in h*) echo match;; esac' 2>&1)
  if [ "$result" = "match" ]; then
      pass "case with wildcard pattern"
  else
  fi
  # Case with multiple patterns
 -result=$("$FORTSH_BIN" -c 'x=b; case $x in a|b|c) echo abc;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=b; case $x in a|b|c) echo abc;; esac' 2>&1)
  if [ "$result" = "abc" ]; then
      pass "case with multiple patterns"
  else
  fi
  # Case with default
 -result=$("$FORTSH_BIN" -c 'x=z; case $x in a) echo a;; *) echo default;; esac' 2>&1)
 +result=$("$SHELL_BIN" -c 'x=z; case $x in a) echo a;; *) echo default;; esac' 2>&1)
  if [ "$result" = "default" ]; then
      pass "case with default pattern"
  else
  # =====================================
  # For loop with break
 -result=$("$FORTSH_BIN" -c 'for i in 1 2 3 4 5; do [ $i -eq 3 ] && break; echo $i; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for i in 1 2 3 4 5; do [ $i -eq 3 ] && break; echo $i; done' 2>&1)
  expected="1
 "
  if [ "$result" = "$expected" ]; then
  fi
  # For loop with continue
 -result=$("$FORTSH_BIN" -c 'for i in 1 2 3 4 5; do [ $i -eq 3 ] && continue; echo $i; done' 2>&1)
 +result=$("$SHELL_BIN" -c 'for i in 1 2 3 4 5; do [ $i -eq 3 ] && continue; echo $i; done' 2>&1)
  if echo "$result" | grep -q "1" && echo "$result" | grep -q "4" && ! echo "$result" | grep -q "3"; then
      pass "for loop with continue"
  else
  # =====================================
  # Subshell variable isolation
 -result=$("$FORTSH_BIN" -c 'X=outer; (X=inner; echo $X); echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=outer; (X=inner; echo $X); echo $X' 2>&1)
  expected="inner
  outer"
  if [ "$result" = "$expected" ]; then
  fi
  # Subshell exit status
 -result=$("$FORTSH_BIN" -c '(exit 42); echo $?' 2>&1)
 +result=$("$SHELL_BIN" -c '(exit 42); echo $?' 2>&1)
  if [ "$result" = "42" ]; then
      pass "subshell exit status captured"
  else
  # =====================================
  # Function with local-like behavior (via subshell)
 -result=$("$FORTSH_BIN" -c 'X=global; f() { (X=local; echo $X); }; f; echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=global; f() { (X=local; echo $X); }; f; echo $X' 2>&1)
  expected="local
  global"
  if [ "$result" = "$expected" ]; then
  fi
  # Recursive function
 -result=$("$FORTSH_BIN" -c 'count() { if [ $1 -gt 0 ]; then echo $1; count $(($1-1)); fi; }; count 3' 2>&1)
 +result=$("$SHELL_BIN" -c 'count() { if [ $1 -gt 0 ]; then echo $1; count $(($1-1)); fi; }; count 3' 2>&1)
  expected="3
 "
  # =====================================
  # Heredoc with variable expansion
 -result=$("$FORTSH_BIN" -c 'X=value; cat <<EOF
 +result=$("$SHELL_BIN" -c 'X=value; cat <<EOF
  $X
  EOF' 2>&1)
  if [ "$result" = "value" ]; then
  fi
  # Quoted heredoc (no expansion)
 -result=$("$FORTSH_BIN" -c 'cat <<'\''EOF'\''
 +result=$("$SHELL_BIN" -c 'cat <<'\''EOF'\''
  $VAR
  EOF' 2>&1)
  if [ "$result" = '$VAR' ]; then
  # =====================================
  # Nested command substitution
 -result=$("$FORTSH_BIN" -c 'echo $(echo $(echo nested))' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo $(echo $(echo nested))' 2>&1)
  if [ "$result" = "nested" ]; then
      pass "nested command substitution"
  else
  fi
  # Command substitution with quotes
 -result=$("$FORTSH_BIN" -c 'echo "$(echo "hello world")"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "$(echo "hello world")"' 2>&1)
  if [ "$result" = "hello world" ]; then
      pass "command substitution with quotes"
  else
  fi
  # Backtick substitution
 -result=$("$FORTSH_BIN" -c 'echo `echo backtick`' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo `echo backtick`' 2>&1)
  if [ "$result" = "backtick" ]; then
      pass "backtick command substitution"
  else
  section "391. EXPR COMMAND"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'expr 5 + 3' 2>&1)
 +result=$("$SHELL_BIN" -c 'expr 5 + 3' 2>&1)
  if [ "$result" = "8" ]; then
      pass "expr addition"
  else
      fail "expr addition" "8" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'expr 10 - 4' 2>&1)
 +result=$("$SHELL_BIN" -c 'expr 10 - 4' 2>&1)
  if [ "$result" = "6" ]; then
      pass "expr subtraction"
  else
      fail "expr subtraction" "6" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'expr 6 \* 7' 2>&1)
 +result=$("$SHELL_BIN" -c 'expr 6 \* 7' 2>&1)
  if [ "$result" = "42" ]; then
      pass "expr multiplication"
  else
      fail "expr multiplication" "42" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'expr 20 / 4' 2>&1)
 +result=$("$SHELL_BIN" -c 'expr 20 / 4' 2>&1)
  if [ "$result" = "5" ]; then
      pass "expr division"
  else
  section "392. TEST COMMAND VARIATIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'test -f /etc/passwd && echo yes' 2>&1)
 +result=$("$SHELL_BIN" -c 'test -f /etc/passwd && echo yes' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test -f regular file"
  else
      fail "test -f regular file" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test -d /tmp && echo yes' 2>&1)
 +result=$("$SHELL_BIN" -c 'test -d /tmp && echo yes' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test -d directory"
  else
      fail "test -d directory" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test 5 -eq 5 && echo yes' 2>&1)
 +result=$("$SHELL_BIN" -c 'test 5 -eq 5 && echo yes' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test numeric equal"
  else
      fail "test numeric equal" "yes" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'test "abc" = "abc" && echo yes' 2>&1)
 +result=$("$SHELL_BIN" -c 'test "abc" = "abc" && echo yes' 2>&1)
  if [ "$result" = "yes" ]; then
      pass "test string equal"
  else
  section "393. BASENAME AND DIRNAME SIMULATION"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'X=/path/to/file.txt; echo ${X##*/}' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=/path/to/file.txt; echo ${X##*/}' 2>&1)
  if [ "$result" = "file.txt" ]; then
      pass "basename via parameter expansion"
  else
      fail "basename via parameter expansion" "file.txt" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'X=/path/to/file.txt; echo ${X%/*}' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=/path/to/file.txt; echo ${X%/*}' 2>&1)
  if [ "$result" = "/path/to" ]; then
      pass "dirname via parameter expansion"
  else
      fail "dirname via parameter expansion" "/path/to" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'X=file.tar.gz; echo ${X%.gz}' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=file.tar.gz; echo ${X%.gz}' 2>&1)
  if [ "$result" = "file.tar" ]; then
      pass "remove extension"
  else
      fail "remove extension" "file.tar" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'X=file.tar.gz; echo ${X%%.*}' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=file.tar.gz; echo ${X%%.*}' 2>&1)
  if [ "$result" = "file" ]; then
      pass "remove all extensions"
  else
  section "394. COMPLEX PIPELINES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo "hello world" | tr " " "\n" | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "hello world" | tr " " "\n" | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "pipeline with tr and wc"
  else
      fail "pipeline with tr and wc" "2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'printf "c\na\nb\n" | sort | head -1' 2>&1)
 +result=$("$SHELL_BIN" -c 'printf "c\na\nb\n" | sort | head -1' 2>&1)
  if [ "$result" = "a" ]; then
      pass "pipeline sort and head"
  else
      fail "pipeline sort and head" "a" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo "test" | cat | cat | cat' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo "test" | cat | cat | cat' 2>&1)
  if [ "$result" = "test" ]; then
      pass "triple cat pipeline"
  else
  section "395. COMMAND GROUPING"
  # =====================================
 -result=$("$FORTSH_BIN" -c '{ echo a; echo b; echo c; } | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo a; echo b; echo c; } | wc -l' 2>&1)
  if [ "$result" -eq 3 ] 2>/dev/null; then
      pass "brace group to pipeline"
  else
      fail "brace group to pipeline" "3" "$result"
  fi
 -result=$("$FORTSH_BIN" -c '(echo x; echo y) | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '(echo x; echo y) | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "subshell to pipeline"
  else
      fail "subshell to pipeline" "2" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'X=1; { X=2; echo $X; }; echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X=1; { X=2; echo $X; }; echo $X' 2>&1)
  expected=$(printf "2\n2")
  if [ "$result" = "$expected" ]; then
      pass "brace group modifies parent var"
  section "396. WORD EXPANSION ORDER"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'X="a b c"; echo $X' 2>&1)
 +result=$("$SHELL_BIN" -c 'X="a b c"; echo $X' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "unquoted var word splits"
  else
      fail "unquoted var word splits" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'X="a b c"; echo "$X"' 2>&1)
 +result=$("$SHELL_BIN" -c 'X="a b c"; echo "$X"' 2>&1)
  if [ "$result" = "a b c" ]; then
      pass "quoted var preserves spaces"
  else
      fail "quoted var preserves spaces" "a b c" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'echo ~ | grep -c "^/"' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo ~ | grep -c "^/"' 2>&1)
  if [ "$result" = "1" ]; then
      pass "tilde expands to home"
  else
  section "397. SIGNAL NAMES"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'kill -l | grep -c HUP' 2>&1)
 +result=$("$SHELL_BIN" -c 'kill -l | grep -c HUP' 2>&1)
  if [ "$result" -ge 1 ]; then
      pass "kill -l shows HUP"
  else
      fail "kill -l shows HUP"
  fi
 -result=$("$FORTSH_BIN" -c 'kill -l | grep -c INT' 2>&1)
 +result=$("$SHELL_BIN" -c 'kill -l | grep -c INT' 2>&1)
  if [ "$result" -ge 1 ]; then
      pass "kill -l shows INT"
  else
      fail "kill -l shows INT"
  fi
 -result=$("$FORTSH_BIN" -c 'kill -l | grep -c TERM' 2>&1)
 +result=$("$SHELL_BIN" -c 'kill -l | grep -c TERM' 2>&1)
  if [ "$result" -ge 1 ]; then
      pass "kill -l shows TERM"
  else
  section "398. EXEC WITH FD"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'exec 3>&1; echo test >&3; exec 3>&-' 2>&1)
 +result=$("$SHELL_BIN" -c 'exec 3>&1; echo test >&3; exec 3>&-' 2>&1)
  if [ "$result" = "test" ]; then
      pass "exec fd redirect"
  else
  section "399. COMPLEX FUNCTIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'max() { [ $1 -gt $2 ] && echo $1 || echo $2; }; max 5 3' 2>&1)
 +result=$("$SHELL_BIN" -c 'max() { [ $1 -gt $2 ] && echo $1 || echo $2; }; max 5 3' 2>&1)
  if [ "$result" = "5" ]; then
      pass "function max returns larger"
  else
      fail "function max returns larger" "5" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'sum() { echo $(($1 + $2)); }; sum 10 20' 2>&1)
 +result=$("$SHELL_BIN" -c 'sum() { echo $(($1 + $2)); }; sum 10 20' 2>&1)
  if [ "$result" = "30" ]; then
      pass "function sum"
  else
      fail "function sum" "30" "$result"
  fi
 -result=$("$FORTSH_BIN" -c 'greet() { echo "Hello, $1!"; }; greet World' 2>&1)
 +result=$("$SHELL_BIN" -c 'greet() { echo "Hello, $1!"; }; greet World' 2>&1)
  if [ "$result" = "Hello, World!" ]; then
      pass "function with string interpolation"
  else
  section "400. ADVANCED REDIRECTIONS"
  # =====================================
 -result=$("$FORTSH_BIN" -c 'echo out; echo err >&2' 2>&1)
 +result=$("$SHELL_BIN" -c 'echo out; echo err >&2' 2>&1)
  expected=$(printf "out\nerr")
  if [ "$result" = "$expected" ]; then
      pass "stdout and stderr"
      fail "stdout and stderr"
  fi
 -result=$("$FORTSH_BIN" -c '{ echo a; echo b >&2; } 2>&1 | wc -l' 2>&1)
 +result=$("$SHELL_BIN" -c '{ echo a; echo b >&2; } 2>&1 | wc -l' 2>&1)
  if [ "$result" -eq 2 ] 2>/dev/null; then
      pass "redirect stderr to stdout in pipeline"
  else

suites/posix/posix_compliance_test.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
      "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
      # Run in fortsh
 -    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
 +    "$SHELL_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
      # Compare outputs
      if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
      "$BASH_REF" -c "$command" > /dev/null 2>&1
      posix_exit=$?
 -    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    "$SHELL_BIN" -c "$command" > /dev/null 2>&1
      fortsh_exit=$?
      if [ "$posix_exit" -eq "$fortsh_exit" ]; then
  # times is optional but common
  # times output contains variable timing values, so just verify format
 -_times_out=$("$FORTSH_BIN" -c 'times' 2>/dev/null)
 +_times_out=$("$SHELL_BIN" -c 'times' 2>/dev/null)
  if echo "$_times_out" | grep -qE '[0-9]+m[0-9]+\.[0-9]+s'; then
      pass "times output exists"
  else

suites/posix/posix_compliance_untested.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
      posix_exit=$?
      # Run with fortsh
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      fortsh_exit=$?
      # Compare outputs
      posix_output=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c "$test_cmd" 2>&1)
      posix_exit=$?
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
      fortsh_exit=$?
      posix_norm=$(normalize_error "$posix_output")
      test_name="$1"
      test_cmd="$2"
 -    if FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +    if FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" >/dev/null 2>&1; then
          pass "$test_name"
      else
          fail "$test_name" "should succeed" "failed or not implemented"
      test_name="$1"
      test_cmd="$2"
 -    if ! FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +    if ! FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" >/dev/null 2>&1; then
          pass "$test_name"
      else
          fail "$test_name" "should fail" "succeeded unexpectedly"

suites/posix/posix_gaps_arithmetic.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_code=$?
 -    "$FORTSH_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
      if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
      else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
+ }

suites/posix/posix_gaps_builtins.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_code=$?
 -    "$FORTSH_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
      if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
      else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
+ }
  compare_posix_error() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }

suites/posix/posix_gaps_charclass.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }

suites/posix/posix_gaps_control.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }
  # Inline test with debug output for CI diagnosis
  _glob_cmd="touch /tmp/posix_gaps_for1_$$.txt /tmp/posix_gaps_for2_$$.txt /tmp/posix_gaps_for3_$$.txt 2>/dev/null; for f in /tmp/posix_gaps_for*_$$.txt; do test -f \$f && echo yes; done | head -1; rm -f /tmp/posix_gaps_for*_$$.txt"
  _glob_posix=$("$BASH_REF" -c "$_glob_cmd" 2>&1)
 -_glob_fortsh=$("$FORTSH_BIN" -c "$_glob_cmd" 2>&1)
 +_glob_fortsh=$("$SHELL_BIN" -c "$_glob_cmd" 2>&1)
  _glob_debug="[DEBUG glob] posix_hex=[$(printf '%s' "$_glob_posix" | od -A n -t x1 | tr -d '\n')] fortsh_hex=[$(printf '%s' "$_glob_fortsh" | od -A n -t x1 | tr -d '\n')] posix_raw=[$_glob_posix] fortsh_raw=[$_glob_fortsh]"
  _glob_posix_n=$(printf '%s' "$_glob_posix" | normalize_output)
  _glob_fortsh_n=$(printf '%s' "$_glob_fortsh" | normalize_output)

suites/posix/posix_gaps_heredoc.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_code=$?
 -    "$FORTSH_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
      if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
      else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
+ }

suites/posix/posix_gaps_quoting.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }

suites/posix/posix_gaps_redirect.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else fail "$test_name" "$posix_out" "$fortsh_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_code=$?
 -    "$FORTSH_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; fortsh_code=$?
      if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
      else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
+ }

suites/posix/posix_gaps_special.shmodified

  # Get script directory (POSIX way)
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 -FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
  # Check if fortsh exists
 -if [ ! -x "$FORTSH_BIN" ]; then
 -    printf "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN\n"
 -    printf "Please run 'make' first or set FORTSH_BIN environment variable\n"
 +if [ ! -x "$SHELL_BIN" ]; then
 +    printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -c "$command" 2>&1 | normalize_output)
 -    fortsh_out=$("$FORTSH_BIN" -c "$command" 2>&1 | normalize_output)
 +    fortsh_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
      if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
      else
          fail "$test_name" "$posix_out" "$fortsh_out"

suites/posix/run_posix_tests.shmodified

  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  # Find fortsh binary - check multiple locations
 -if [ -n "$FORTSH_BIN" ] && [ -x "$FORTSH_BIN" ]; then
 +if [ -n "$SHELL_BIN" ] && [ -x "$SHELL_BIN" ]; then
      # Use environment variable if set
 -    FORTSH_PATH="$FORTSH_BIN"
 +    FORTSH_PATH="$SHELL_BIN"
  elif [ -x "$SCRIPT_DIR/../bin/fortsh" ]; then
      # Look in ../bin/fortsh (relative to tests/)
      FORTSH_PATH="$SCRIPT_DIR/../bin/fortsh"
      # Look in current working directory
      FORTSH_PATH="$(pwd)/bin/fortsh"
  else
 -    printf "${RED}ERROR: fortsh binary not found!${NC}\n"
 +    printf "${RED}ERROR: shell binary not found!${NC}\n"
      printf "Searched locations:\n"
 -    printf "  - FORTSH_BIN environment variable\n"
 +    printf "  - SHELL_BIN environment variable\n"
      printf "  - %s/bin/fortsh\n" "$SCRIPT_DIR/.."
      printf "  - ./bin/fortsh\n"
      printf "  - $(pwd)/bin/fortsh\n"
 -    printf "\nPlease build fortsh first with 'make' or set FORTSH_BIN\n"
 +    printf "\nPlease build fortsh first with 'make' or set SHELL_BIN\n"
      exit 1
  fi
 -export FORTSH_BIN="$FORTSH_PATH"
 +export SHELL_BIN="$FORTSH_PATH"
  # Test suite files
  TEST_SUITES="
  printf "${CYAN}========================================\n"
  printf "POSIX Compliance Test Suite Runner\n"
  printf "========================================${NC}\n"
 -printf "fortsh binary: ${GREEN}%s${NC}\n" "$FORTSH_BIN"
 +printf "fortsh binary: ${GREEN}%s${NC}\n" "$SHELL_BIN"
  printf "Test directory: %s\n" "$SCRIPT_DIR"
  printf "\n"

suites/test_harness.shmodified

  # Check if fortsh exists
  if [ ! -x "$SHELL_BIN" ]; then
      printf "${RED}ERROR${NC}: shell binary not found at $SHELL_BIN\n"
 -    printf "Please run 'make' first or set SHELL_BIN environment variable\n"
 +    printf "Please set SHELL_BIN or set SHELL_BIN environment variable\n"
      exit 1
  fi

tenseleyflow/bensch / `5356b21`

40 changed files