`73a6465`

generalize error normalization and rename fortsh references

- normalize_shell_name() now catches any *sh: prefix, not just bash/fortsh
- Debug output labels: 'fortsh:' -> 'shell:'
- Variable names: fortsh_file -> shell_file, fortsh_code -> shell_code, etc.
- Temp file paths: /tmp/fortsh_* -> /tmp/bensch_*
- Comments and descriptions: 'for fortsh' -> generic

Authored by

espadonne 1 month ago

SHA: 73a64656905843e9a409b02a9f914f5d8b8297f6
Parents: 5356b21
Tree: be1810a

30 changed files

Status	File	+	-
M	`suites/builtins/integration/run_integration_tests.sh`	1	1
M	`suites/builtins/portable/test_stress.sh`	6	6
M	`suites/builtins/run_builtin_tests.sh`	1	1
M	`suites/posix/posix_compliance_advanced.sh`	13	13
M	`suites/posix/posix_compliance_builtins.sh`	35	35
M	`suites/posix/posix_compliance_charclass.sh`	3	3
M	`suites/posix/posix_compliance_control.sh`	6	6
M	`suites/posix/posix_compliance_coverage.sh`	11	11
M	`suites/posix/posix_compliance_extended.sh`	12	12
M	`suites/posix/posix_compliance_filetest.sh`	3	3
M	`suites/posix/posix_compliance_gaps.sh`	21	21
M	`suites/posix/posix_compliance_heredoc.sh`	3	3
M	`suites/posix/posix_compliance_jobcontrol.sh`	1	1
M	`suites/posix/posix_compliance_options.sh`	6	6
M	`suites/posix/posix_compliance_printf.sh`	2	2
M	`suites/posix/posix_compliance_quoting.sh`	2	2
M	`suites/posix/posix_compliance_redirect.sh`	3	3
M	`suites/posix/posix_compliance_special.sh`	1	1
M	`suites/posix/posix_compliance_test.sh`	12	12
M	`suites/posix/posix_compliance_untested.sh`	12	12
M	`suites/posix/posix_gaps_arithmetic.sh`	9	9
M	`suites/posix/posix_gaps_builtins.sh`	12	12
M	`suites/posix/posix_gaps_charclass.sh`	6	6
M	`suites/posix/posix_gaps_control.sh`	11	11
M	`suites/posix/posix_gaps_heredoc.sh`	9	9
M	`suites/posix/posix_gaps_quoting.sh`	6	6
M	`suites/posix/posix_gaps_redirect.sh`	9	9
M	`suites/posix/posix_gaps_special.sh`	7	7
M	`suites/posix/run_posix_tests.sh`	1	1
M	`suites/test_harness.sh`	5	5

suites/builtins/integration/run_integration_tests.shmodified

  else
      run_with_timeout() {
          _rwt_secs="$1"; shift
 -        _rwt_tmp=$(mktemp /tmp/fortsh_timeout.XXXXXX)
 +        _rwt_tmp=$(mktemp /tmp/bensch_timeout.XXXXXX)
          ( "$@" ) > "$_rwt_tmp" 2>&1 &
          _rwt_pid=$!
          ( sleep "$_rwt_secs"; kill "$_rwt_pid" 2>/dev/null ) &

suites/builtins/portable/test_stress.shmodified

  section "22 - FD and redirection stress"
  compare_output "rapid redirect cycling 100 iterations" \
 -  'i=1; while [ $i -le 100 ]; do echo $i > /tmp/fortsh_test_fd_$$; i=$((i+1)); done; cat /tmp/fortsh_test_fd_$$; rm -f /tmp/fortsh_test_fd_$$'
 +  'i=1; while [ $i -le 100 ]; do echo $i > /tmp/bensch_test_fd_$$; i=$((i+1)); done; cat /tmp/bensch_test_fd_$$; rm -f /tmp/bensch_test_fd_$$'
  compare_output "append redirect 200 lines" \
 -  'rm -f /tmp/fortsh_test_append_$$; i=1; while [ $i -le 200 ]; do echo $i >> /tmp/fortsh_test_append_$$; i=$((i+1)); done; wc -l < /tmp/fortsh_test_append_$$; rm -f /tmp/fortsh_test_append_$$'
 +  'rm -f /tmp/bensch_test_append_$$; i=1; while [ $i -le 200 ]; do echo $i >> /tmp/bensch_test_append_$$; i=$((i+1)); done; wc -l < /tmp/bensch_test_append_$$; rm -f /tmp/bensch_test_append_$$'
  compare_output "stderr redirect in loop" \
    'for i in 1 2 3 4 5; do echo "err$i" >&2; done 2>&1 | wc -l'
  section "29 - Glob expansion"
  compare_output "glob with many matches" \
 -  'mkdir -p /tmp/fortsh_glob_$$; i=1; while [ $i -le 200 ]; do touch /tmp/fortsh_glob_$$/f$i.txt; i=$((i+1)); done; ls /tmp/fortsh_glob_$$/*.txt | wc -l; rm -rf /tmp/fortsh_glob_$$'
 +  'mkdir -p /tmp/bensch_glob_$$; i=1; while [ $i -le 200 ]; do touch /tmp/bensch_glob_$$/f$i.txt; i=$((i+1)); done; ls /tmp/bensch_glob_$$/*.txt | wc -l; rm -rf /tmp/bensch_glob_$$'
  # Use check_output for glob no-match since $$ differs between bash and fortsh
  check_output "glob with no matches nullglob off" \
    '/tmp/no_such_dir_xyz/*.abc'
  compare_output "glob bracket expression" \
 -  'mkdir -p /tmp/fortsh_glob2_$$; touch /tmp/fortsh_glob2_$$/a1 /tmp/fortsh_glob2_$$/b2 /tmp/fortsh_glob2_$$/c3; ls /tmp/fortsh_glob2_$$/[abc][0-9] | wc -l; rm -rf /tmp/fortsh_glob2_$$'
 +  'mkdir -p /tmp/bensch_glob2_$$; touch /tmp/bensch_glob2_$$/a1 /tmp/bensch_glob2_$$/b2 /tmp/bensch_glob2_$$/c3; ls /tmp/bensch_glob2_$$/[abc][0-9] | wc -l; rm -rf /tmp/bensch_glob2_$$'
  compare_output "glob question mark" \
 -  'mkdir -p /tmp/fortsh_glob3_$$; touch /tmp/fortsh_glob3_$$/ax /tmp/fortsh_glob3_$$/bx /tmp/fortsh_glob3_$$/cx; echo /tmp/fortsh_glob3_$$/?x | wc -w; rm -rf /tmp/fortsh_glob3_$$'
 +  'mkdir -p /tmp/bensch_glob3_$$; touch /tmp/bensch_glob3_$$/ax /tmp/bensch_glob3_$$/bx /tmp/bensch_glob3_$$/cx; echo /tmp/bensch_glob3_$$/?x | wc -w; rm -rf /tmp/bensch_glob3_$$'
  # ==========================================
  # 30. Eval & dynamic execution stress
    '{ echo hello; echo world; } | sort'
  compare_output "brace group with redirect" \
 -  '{ echo line1; echo line2; echo line3; } > /tmp/fortsh_brace_$$; wc -l < /tmp/fortsh_brace_$$; rm -f /tmp/fortsh_brace_$$'
 +  '{ echo line1; echo line2; echo line3; } > /tmp/bensch_brace_$$; wc -l < /tmp/bensch_brace_$$; rm -f /tmp/bensch_brace_$$'
  compare_output "nested brace groups" \
    '{ { { echo deep; }; }; }'

suites/builtins/run_builtin_tests.shmodified

      # POSIX fallback using temp file for output capture compatibility
      run_with_timeout() {
          _rwt_secs="$1"; shift
 -        _rwt_tmp=$(mktemp /tmp/fortsh_timeout.XXXXXX)
 +        _rwt_tmp=$(mktemp /tmp/bensch_timeout.XXXXXX)
          ( "$@" ) > "$_rwt_tmp" 2>&1 &
          _rwt_pid=$!
          ( sleep "$_rwt_secs"; kill "$_rwt_pid" 2>/dev/null ) &

suites/posix/posix_compliance_advanced.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Advanced Test Suite for fortsh
 +# POSIX Compliance Advanced Test Suite for shell
  # =====================================
  # Additional coverage based on OpenGroup POSIX.1-2017 specification
  # Fills gaps not covered in basic, extended, and builtins test suites
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
          printf "  posix:  %s\n" "$2"
      fi
      if [ -n "$3" ]; then
 -        printf "  fortsh: %s\n" "$3"
 +        printf "  shell: %s\n" "$3"
      fi
      FAILED=$((FAILED + 1))
+ }
  # Normalize shell error messages by stripping shell name and "line N: " prefix
  normalize_output() {
 -    sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'
 +    sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'
+ }
  # Helper function to run command in both shells and compare
      test_name="$1"
      command="$2"
      posix_file="/tmp/posix_adv_$$_posix"
 -    fortsh_file="/tmp/posix_adv_$$_fortsh"
 +    shell_file="/tmp/posix_adv_$$_shell"
      # Run in POSIX shell (sh)
      "$BASH_REF" -c "$command" 2>&1 | normalize_output > "$posix_file" || true
 -    # Run in fortsh
 -    "$SHELL_BIN" -c "$command" 2>&1 | normalize_output > "$fortsh_file" || true
 +    # Run in shell under test
 +    "$SHELL_BIN" -c "$command" 2>&1 | normalize_output > "$shell_file" || true
      # Compare outputs
 -    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +    if diff -q "$posix_file" "$shell_file" > /dev/null 2>&1; then
          pass "$test_name"
      else
 -        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$shell_file")"
      fi
 -    rm -f "$posix_file" "$fortsh_file"
 +    rm -f "$posix_file" "$shell_file"
+ }
  # Helper function to compare exit codes
      posix_exit=$?
      "$SHELL_BIN" -c "$command" > /dev/null 2>&1
 -    fortsh_exit=$?
 +    shell_exit=$?
 -    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +    if [ "$posix_exit" -eq "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +        fail "$test_name" "exit=$posix_exit" "exit=$shell_exit"
      fi
+ }

suites/posix/posix_compliance_builtins.shmodified

      section "P1-1: Exit Code 126 (Non-executable File)"
      # Test 1: Non-executable file returns 126
 -    touch /tmp/fortsh_test_nonexec
 -    chmod 644 /tmp/fortsh_test_nonexec
 -    $SHELL_BIN -c '/tmp/fortsh_test_nonexec' >/dev/null 2>&1
 +    touch /tmp/bensch_test_nonexec
 +    chmod 644 /tmp/bensch_test_nonexec
 +    $SHELL_BIN -c '/tmp/bensch_test_nonexec' >/dev/null 2>&1
      exit_code=$?
 -    rm -f /tmp/fortsh_test_nonexec
 +    rm -f /tmp/bensch_test_nonexec
      if [ $exit_code -eq 126 ]; then
          pass "P1-1.1: Non-executable file returns exit code 126"
      fi
      # Test 3: Executable file returns its own exit code
 -    echo '#!/bin/sh' > /tmp/fortsh_test_exec
 -    echo 'exit 5' >> /tmp/fortsh_test_exec
 -    chmod 755 /tmp/fortsh_test_exec
 -    $SHELL_BIN -c '/tmp/fortsh_test_exec' >/dev/null 2>&1
 +    echo '#!/bin/sh' > /tmp/bensch_test_exec
 +    echo 'exit 5' >> /tmp/bensch_test_exec
 +    chmod 755 /tmp/bensch_test_exec
 +    $SHELL_BIN -c '/tmp/bensch_test_exec' >/dev/null 2>&1
      exit_code=$?
 -    rm -f /tmp/fortsh_test_exec
 +    rm -f /tmp/bensch_test_exec
      if [ $exit_code -eq 5 ]; then
          pass "P1-1.3: Executable file returns its own exit code"
      section "P1-2: set -C (noclobber option)"
      # Test 1: set -C prevents overwriting existing files
 -    echo "original" > /tmp/fortsh_test_noclobber
 -    $SHELL_BIN -c 'set -C; echo new > /tmp/fortsh_test_noclobber' >/dev/null 2>&1
 +    echo "original" > /tmp/bensch_test_noclobber
 +    $SHELL_BIN -c 'set -C; echo new > /tmp/bensch_test_noclobber' >/dev/null 2>&1
      exit_code=$?
 -    content=$(cat /tmp/fortsh_test_noclobber 2>/dev/null)
 -    rm -f /tmp/fortsh_test_noclobber
 +    content=$(cat /tmp/bensch_test_noclobber 2>/dev/null)
 +    rm -f /tmp/bensch_test_noclobber
      if [ $exit_code -ne 0 ] && [ "$content" = "original" ]; then
          pass "P1-2.1: set -C prevents overwriting existing files"
      fi
      # Test 2: set -C allows writing to new files
 -    rm -f /tmp/fortsh_test_noclobber_new
 -    $SHELL_BIN -c 'set -C; echo content > /tmp/fortsh_test_noclobber_new' >/dev/null 2>&1
 -    if [ -f /tmp/fortsh_test_noclobber_new ]; then
 +    rm -f /tmp/bensch_test_noclobber_new
 +    $SHELL_BIN -c 'set -C; echo content > /tmp/bensch_test_noclobber_new' >/dev/null 2>&1
 +    if [ -f /tmp/bensch_test_noclobber_new ]; then
          pass "P1-2.2: set -C allows writing to non-existent files"
 -        rm -f /tmp/fortsh_test_noclobber_new
 +        rm -f /tmp/bensch_test_noclobber_new
      else
          fail "P1-2.2: set -C allows writing to non-existent files"
      fi
      # Test 3: >| forces overwrite even with noclobber
 -    echo "original" > /tmp/fortsh_test_force
 -    $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
 +    echo "original" > /tmp/bensch_test_force
 +    $SHELL_BIN -c 'set -C; echo forced >| /tmp/bensch_test_force' >/dev/null 2>&1
 +    content=$(cat /tmp/bensch_test_force 2>/dev/null)
 +    rm -f /tmp/bensch_test_force
      if [ "$content" = "forced" ]; then
          pass "P1-2.3: >| forces overwrite with noclobber set"
      fi
      # Test 4: set +C disables noclobber
 -    echo "original" > /tmp/fortsh_test_disable
 -    $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
 +    echo "original" > /tmp/bensch_test_disable
 +    $SHELL_BIN -c 'set -C; set +C; echo new > /tmp/bensch_test_disable' >/dev/null 2>&1
 +    content=$(cat /tmp/bensch_test_disable 2>/dev/null)
 +    rm -f /tmp/bensch_test_disable
      if [ "$content" = "new" ]; then
          pass "P1-2.4: set +C disables noclobber option"
      section "P2-2: dot (.) Source with Arguments"
      # Test 1: Source script with positional parameters
 -    echo 'echo "arg1=$1 arg2=$2"' > /tmp/fortsh_test_source
 -    output=$($SHELL_BIN -c '. /tmp/fortsh_test_source hello world' 2>&1)
 -    rm -f /tmp/fortsh_test_source
 +    echo 'echo "arg1=$1 arg2=$2"' > /tmp/bensch_test_source
 +    output=$($SHELL_BIN -c '. /tmp/bensch_test_source hello world' 2>&1)
 +    rm -f /tmp/bensch_test_source
      if echo "$output" | grep -q "arg1=hello arg2=world"; then
          pass "P2-2.1: dot command passes arguments to sourced script"
      fi
      # Test 2: Source script preserves caller's variables
 -    echo 'SOURCED_VAR=from_script' > /tmp/fortsh_test_source2
 -    output=$($SHELL_BIN -c '. /tmp/fortsh_test_source2; echo $SOURCED_VAR' 2>&1)
 -    rm -f /tmp/fortsh_test_source2
 +    echo 'SOURCED_VAR=from_script' > /tmp/bensch_test_source2
 +    output=$($SHELL_BIN -c '. /tmp/bensch_test_source2; echo $SOURCED_VAR' 2>&1)
 +    rm -f /tmp/bensch_test_source2
      if echo "$output" | grep -q "from_script"; then
          pass "P2-2.2: Sourced script sets variables in caller"
      fi
      # Test 3: Source with absolute path
 -    echo 'echo sourced' > /tmp/fortsh_abs_source
 -    output=$($SHELL_BIN -c '. /tmp/fortsh_abs_source' 2>&1)
 -    rm -f /tmp/fortsh_abs_source
 +    echo 'echo sourced' > /tmp/bensch_abs_source
 +    output=$($SHELL_BIN -c '. /tmp/bensch_abs_source' 2>&1)
 +    rm -f /tmp/bensch_abs_source
      if echo "$output" | grep -q "sourced"; then
          pass "P2-2.3: dot command works with absolute paths"
      echo "Date: $(date)"
      echo ""
 -    # Verify fortsh exists
 +    # Verify shell binary exists
      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"

suites/posix/posix_compliance_charclass.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Character Class Test Suite for fortsh
 +# POSIX Compliance Character Class Test Suite for shell
  # =====================================
  # Tests POSIX bracket expression character classes per IEEE Std 1003.1-2017
  # Section 9.3.5 RE Bracket Expression
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
  # Create test directory with test files
  setup_test_files() {
 -    TEST_DIR="/tmp/fortsh_charclass_$$"
 +    TEST_DIR="/tmp/bensch_charclass_$$"
      mkdir -p "$TEST_DIR"
      cd "$TEST_DIR" || exit 1

suites/posix/posix_compliance_control.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Control Flow and Grouping Test Suite for fortsh
 +# POSIX Compliance Control Flow and Grouping Test Suite for shell
  # =====================================
  # Tests control flow, subshells, brace groups per IEEE Std 1003.1-2017
  # Section: Shell Command Language - Compound Commands
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
  section "420. DOT (SOURCE) COMMAND"
  # =====================================
 -TEST_DIR="/tmp/fortsh_control_$$"
 +TEST_DIR="/tmp/bensch_control_$$"
  mkdir -p "$TEST_DIR"
  # Create a file to source
  # Note: (( )) is arithmetic syntax in bash, not nested subshell
  # Both bash and fortsh correctly treat this as arithmetic and error
  "$SHELL_BIN" -c '((echo deep))' >/dev/null 2>&1
 -fortsh_exit=$?
 +shell_exit=$?
  "$BASH_REF" -c '((echo deep))' >/dev/null 2>&1
  bash_exit=$?
 -if [ "$fortsh_exit" -eq "$bash_exit" ]; then
 +if [ "$shell_exit" -eq "$bash_exit" ]; then
      pass "double paren arithmetic exit"
  else
 -    fail "double paren arithmetic exit" "exit=$bash_exit" "exit=$fortsh_exit"
 +    fail "double paren arithmetic exit" "exit=$bash_exit" "exit=$shell_exit"
  fi
  # =====================================

suites/posix/posix_compliance_coverage.shmodified

  # Normalize output by stripping shell name prefix
  normalize_output() {
 -    sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'
 +    sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'
+ }
  # Compare output between sh and fortsh
      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 "$SHELL_BIN" -c "$test_cmd" 2>&1 | normalize_output)
 -    fortsh_exit=$?
 +    shell_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1 | normalize_output)
 +    shell_exit=$?
 -    if [ "$posix_output" = "$fortsh_output" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +    if [ "$posix_output" = "$shell_output" ] && [ "$posix_exit" = "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "$posix_output" "$fortsh_output"
 +        fail "$test_name" "$posix_output" "$shell_output"
      fi
+ }
  # Normalize shell error messages by stripping shell name and "line N: " prefix
  # POSIX doesn't mandate error message format, so we normalize for comparison
  normalize_error() {
 -    echo "$1" | sed -e 's|^[^ ]*bash: |sh: |g' -e 's|[^ ]*bash: |sh: |g' -e 's|^[^ ]*fortsh: |sh: |g' -e 's|[^ ]*fortsh: |sh: |g' -e 's/line [0-9]*: //g' -e 's/-c: //g'
 +    echo "$1" | sed -e 's|^[^ ]*bash: |sh: |g' -e 's|[^ ]*bash: |sh: |g' -e 's|^[a-z]*sh[0-9]*: |sh: |g' -e 's|[a-z]*sh[0-9]*: |sh: |g' -e 's/line [0-9]*: //g' -e 's/-c: //g'
+ }
  # Compare error output, normalizing line number differences
      posix_output=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c "$test_cmd" 2>&1)
      posix_exit=$?
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
 -    fortsh_exit=$?
 +    shell_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
 +    shell_exit=$?
      posix_norm=$(normalize_error "$posix_output")
 -    fortsh_norm=$(normalize_error "$fortsh_output")
 +    shell_norm=$(normalize_error "$shell_output")
 -    if [ "$posix_norm" = "$fortsh_norm" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +    if [ "$posix_norm" = "$shell_norm" ] && [ "$posix_exit" = "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "$posix_output" "$fortsh_output"
 +        fail "$test_name" "$posix_output" "$shell_output"
      fi
+ }

suites/posix/posix_compliance_extended.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Extended Test Suite for fortsh
 +# POSIX Compliance Extended Test Suite for shell
  # =====================================
  # Comprehensive POSIX compliance testing based on IEEE Std 1003.1-2017
  # This extends the basic test suite with additional coverage
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
          printf "  posix:  %s\n" "$2"
      fi
      if [ -n "$3" ]; then
 -        printf "  fortsh: %s\n" "$3"
 +        printf "  shell: %s\n" "$3"
      fi
      FAILED=$((FAILED + 1))
+ }
      test_name="$1"
      command="$2"
      posix_file="/tmp/posix_ext_$$_posix"
 -    fortsh_file="/tmp/posix_ext_$$_fortsh"
 +    shell_file="/tmp/posix_ext_$$_fortsh"
      # Run in POSIX shell (sh)
      "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
 -    # Run in fortsh
 -    "$SHELL_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
 +    # Run in shell under test
 +    "$SHELL_BIN" -c "$command" > "$shell_file" 2>&1 || true
      # Compare outputs
 -    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +    if diff -q "$posix_file" "$shell_file" > /dev/null 2>&1; then
          pass "$test_name"
      else
 -        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$shell_file")"
      fi
 -    rm -f "$posix_file" "$fortsh_file"
 +    rm -f "$posix_file" "$shell_file"
+ }
  # Helper function to compare exit codes
      posix_exit=$?
      "$SHELL_BIN" -c "$command" > /dev/null 2>&1
 -    fortsh_exit=$?
 +    shell_exit=$?
 -    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +    if [ "$posix_exit" -eq "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +        fail "$test_name" "exit=$posix_exit" "exit=$shell_exit"
      fi
+ }

suites/posix/posix_compliance_filetest.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance File Test Operators Suite for fortsh
 +# POSIX Compliance File Test Operators Suite for shell
  # =====================================
  # Tests test/[ builtin file and string operators per IEEE Std 1003.1-2017
  # Section: Shell Command Language - Conditional Expressions
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
  # Create test directory with test files
  setup_test_files() {
 -    TEST_DIR="/tmp/fortsh_filetest_$$"
 +    TEST_DIR="/tmp/shell_filetest_$$"
      mkdir -p "$TEST_DIR"
      cd "$TEST_DIR" || exit 1

suites/posix/posix_compliance_gaps.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
          printf "  posix:  %s\n" "$2"
      fi
      if [ -n "$3" ]; then
 -        printf "  fortsh: %s\n" "$3"
 +        printf "  shell: %s\n" "$3"
      fi
      FAILED=$((FAILED + 1))
+ }
  # Normalize shell error messages by stripping shell name and "line N: " prefix
  normalize_output() {
 -    sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'
 +    sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'
+ }
  # Helper function to run command in both shells and compare
      test_name="$1"
      command="$2"
      posix_file="/tmp/posix_gaps_$$_posix"
 -    fortsh_file="/tmp/posix_gaps_$$_fortsh"
 +    shell_file="/tmp/posix_gaps_$$_fortsh"
      # Run in POSIX shell (sh)
      "$BASH_REF" -c "$command" 2>&1 | normalize_output > "$posix_file" || true
 -    # Run in fortsh
 -    "$SHELL_BIN" -c "$command" 2>&1 | normalize_output > "$fortsh_file" || true
 +    # Run in shell under test
 +    "$SHELL_BIN" -c "$command" 2>&1 | normalize_output > "$shell_file" || true
      # Compare outputs
 -    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +    if diff -q "$posix_file" "$shell_file" > /dev/null 2>&1; then
          pass "$test_name"
      else
 -        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$shell_file")"
      fi
 -    rm -f "$posix_file" "$fortsh_file"
 +    rm -f "$posix_file" "$shell_file"
+ }
  # Normalize shell error messages by stripping shell name and "line N: " prefix
  # POSIX doesn't mandate error message format, so we normalize for comparison
  normalize_error() {
 -    echo "$1" | sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'
 +    echo "$1" | sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'
+ }
  # Compare error output, normalizing line number differences
      test_name="$1"
      command="$2"
      posix_file="/tmp/posix_gaps_$$_posix"
 -    fortsh_file="/tmp/posix_gaps_$$_fortsh"
 +    shell_file="/tmp/posix_gaps_$$_fortsh"
      # Run in POSIX shell (sh)
      "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
 -    # Run in fortsh
 -    "$SHELL_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
 +    # Run in shell under test
 +    "$SHELL_BIN" -c "$command" > "$shell_file" 2>&1 || true
      # Normalize error messages before comparison
      posix_norm=$(normalize_error "$(cat "$posix_file")")
 -    fortsh_norm=$(normalize_error "$(cat "$fortsh_file")")
 +    shell_norm=$(normalize_error "$(cat "$shell_file")")
 -    if [ "$posix_norm" = "$fortsh_norm" ]; then
 +    if [ "$posix_norm" = "$shell_norm" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$shell_file")"
      fi
 -    rm -f "$posix_file" "$fortsh_file"
 +    rm -f "$posix_file" "$shell_file"
+ }
  # Helper function to compare exit codes
      posix_exit=$?
      "$SHELL_BIN" -c "$command" > /dev/null 2>&1
 -    fortsh_exit=$?
 +    shell_exit=$?
 -    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +    if [ "$posix_exit" -eq "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +        fail "$test_name" "exit=$posix_exit" "exit=$shell_exit"
          # Accumulate debug info for CI summary
          DEBUG_INFO="${DEBUG_INFO}DEBUG [$test_name]: cmd='$command'\n"
          DEBUG_INFO="${DEBUG_INFO}  bash exit: $posix_exit\n"
 -        DEBUG_INFO="${DEBUG_INFO}  fortsh exit: $fortsh_exit\n"
 +        DEBUG_INFO="${DEBUG_INFO}  fortsh exit: $shell_exit\n"
      fi
+ }

suites/posix/posix_compliance_heredoc.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Here-Document and Expansion Test Suite for fortsh
 +# POSIX Compliance Here-Document and Expansion Test Suite for shell
  # =====================================
  # Tests here-documents and parameter expansion per IEEE Std 1003.1-2017
  # Section: Shell Command Language - Here-Documents, Parameter Expansion
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
  else
      _timeout() {
          _to_secs="$1"; shift
 -        _to_tmp=$(mktemp /tmp/fortsh_timeout.XXXXXX)
 +        _to_tmp=$(mktemp /tmp/bensch_timeout.XXXXXX)
          ( "$@" ) > "$_to_tmp" 2>&1 &
          _to_pid=$!
          ( sleep "$_to_secs"; kill "$_to_pid" 2>/dev/null ) &

suites/posix/posix_compliance_jobcontrol.shmodified

  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"

suites/posix/posix_compliance_options.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Shell Options and Read Builtin Test Suite for fortsh
 +# POSIX Compliance Shell Options and Read Builtin Test Suite for shell
  # =====================================
  # Tests set options and read builtin per IEEE Std 1003.1-2017
  # Section: Shell Command Language - set, read
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
  # Note: set -v only echoes lines as they're READ, not from -c argument
  # Test that -v option is accepted and runs without error
  "$SHELL_BIN" -c 'set -v; echo hello' >/dev/null 2>&1
 -fortsh_exit=$?
 +shell_exit=$?
  "$BASH_REF" -c 'set -v; echo hello' >/dev/null 2>&1
  bash_exit=$?
 -if [ "$fortsh_exit" -eq "$bash_exit" ]; then
 +if [ "$shell_exit" -eq "$bash_exit" ]; then
      pass "set -v runs without error"
  else
 -    fail "set -v runs without error" "exit=$bash_exit" "exit=$fortsh_exit"
 +    fail "set -v runs without error" "exit=$bash_exit" "exit=$shell_exit"
  fi
  # =====================================
  section "387. SET -C (NOCLOBBER)"
  # =====================================
 -TEST_DIR="/tmp/fortsh_options_$$"
 +TEST_DIR="/tmp/bensch_options_$$"
  mkdir -p "$TEST_DIR"
  result=$("$SHELL_BIN" -c 'set -C; echo test > '"$TEST_DIR"'/clobber1; echo test2 > '"$TEST_DIR"'/clobber1' 2>&1)

suites/posix/posix_compliance_printf.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance printf Builtin Test Suite for fortsh
 +# POSIX Compliance printf Builtin Test Suite for shell
  # =====================================
  # Tests the printf builtin command per IEEE Std 1003.1-2017
  # Section: Shell & Utilities - printf
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"

suites/posix/posix_compliance_quoting.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Quoting Test Suite for fortsh
 +# POSIX Compliance Quoting Test Suite for shell
  # =====================================
  # Tests quoting and escaping per IEEE Std 1003.1-2017
  # Section: Shell Command Language - Quoting
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"

suites/posix/posix_compliance_redirect.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Redirection and Pipeline Test Suite for fortsh
 +# POSIX Compliance Redirection and Pipeline Test Suite for shell
  # =====================================
  # Tests redirections and pipelines per IEEE Std 1003.1-2017
  # Section: Shell Command Language - Redirection
  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "==========================================${NC}\n"
+ }
 -TEST_DIR="/tmp/fortsh_redirect_$$"
 +TEST_DIR="/tmp/bensch_redirect_$$"
  mkdir -p "$TEST_DIR"
  cleanup() {

suites/posix/posix_compliance_special.shmodified

  SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"

suites/posix/posix_compliance_test.shmodified

  #!/bin/sh
  # =====================================
 -# POSIX Compliance Test Suite for fortsh
 +# POSIX Compliance Test Suite for shell
  # =====================================
  # Tests compliance with POSIX shell specification
  # Uses /bin/sh for comparison (typically dash or bash in POSIX mode)
  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
          printf "  posix:  %s\n" "$2"
      fi
      if [ -n "$3" ]; then
 -        printf "  fortsh: %s\n" "$3"
 +        printf "  shell: %s\n" "$3"
      fi
      FAILED=$((FAILED + 1))
+ }
      test_name="$1"
      command="$2"
      posix_file="/tmp/posix_comp_$$_posix"
 -    fortsh_file="/tmp/posix_comp_$$_fortsh"
 +    shell_file="/tmp/posix_comp_$$_fortsh"
      # Run in POSIX shell (sh)
      "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
 -    # Run in fortsh
 -    "$SHELL_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
 +    # Run in shell under test
 +    "$SHELL_BIN" -c "$command" > "$shell_file" 2>&1 || true
      # Compare outputs
 -    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +    if diff -q "$posix_file" "$shell_file" > /dev/null 2>&1; then
          pass "$test_name"
      else
 -        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$shell_file")"
      fi
 -    rm -f "$posix_file" "$fortsh_file"
 +    rm -f "$posix_file" "$shell_file"
+ }
  # Helper function to compare exit codes
      posix_exit=$?
      "$SHELL_BIN" -c "$command" > /dev/null 2>&1
 -    fortsh_exit=$?
 +    shell_exit=$?
 -    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +    if [ "$posix_exit" -eq "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +        fail "$test_name" "exit=$posix_exit" "exit=$shell_exit"
      fi
+ }

suites/posix/posix_compliance_untested.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
          printf "  posix:         %s\n" "$2"
      fi
      if [ -n "$3" ]; then
 -        printf "  fortsh:        %s\n" "$3"
 +        printf "  shell:        %s\n" "$3"
      fi
      FAILED=$((FAILED + 1))
+ }
      posix_exit=$?
      # Run with fortsh
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
 -    fortsh_exit=$?
 +    shell_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
 +    shell_exit=$?
      # Compare outputs
 -    if [ "$posix_output" = "$fortsh_output" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +    if [ "$posix_output" = "$shell_output" ] && [ "$posix_exit" = "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "$posix_output" "$fortsh_output"
 +        fail "$test_name" "$posix_output" "$shell_output"
      fi
+ }
  # Normalize shell error messages by stripping shell name and "line N: " prefix
  # POSIX doesn't mandate error message format, so we normalize for comparison
  normalize_error() {
 -    echo "$1" | sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'
 +    echo "$1" | sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'
+ }
  # Compare error output, normalizing line number differences
      posix_output=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c "$test_cmd" 2>&1)
      posix_exit=$?
 -    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
 -    fortsh_exit=$?
 +    shell_output=$(FORTSH_RC_FILE=/dev/null "$SHELL_BIN" -c "$test_cmd" 2>&1)
 +    shell_exit=$?
      posix_norm=$(normalize_error "$posix_output")
 -    fortsh_norm=$(normalize_error "$fortsh_output")
 +    shell_norm=$(normalize_error "$shell_output")
 -    if [ "$posix_norm" = "$fortsh_norm" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +    if [ "$posix_norm" = "$shell_norm" ] && [ "$posix_exit" = "$shell_exit" ]; then
          pass "$test_name"
      else
 -        fail "$test_name" "$posix_output" "$fortsh_output"
 +        fail "$test_name" "$posix_output" "$shell_output"
      fi
+ }

suites/posix/posix_gaps_arithmetic.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_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
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; shell_code=$?
 +    if [ "$posix_code" = "$shell_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $shell_code"; fi
+ }
  # ============================================================================

suites/posix/posix_gaps_builtins.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_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
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; shell_code=$?
 +    if [ "$posix_code" = "$shell_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $shell_code"; fi
+ }
  compare_posix_error() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  # ============================================================================

suites/posix/posix_gaps_charclass.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  # ============================================================================

suites/posix/posix_gaps_control.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_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=$("$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_shell=$("$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')] shell_hex=[$(printf '%s' "$_glob_shell" | od -A n -t x1 | tr -d '\n')] posix_raw=[$_glob_posix] shell_raw=[$_glob_shell]"
  _glob_posix_n=$(printf '%s' "$_glob_posix" | normalize_output)
 -_glob_fortsh_n=$(printf '%s' "$_glob_fortsh" | normalize_output)
 -if [ "$_glob_posix_n" = "$_glob_fortsh_n" ]; then pass "for glob expansion"
 -else fail "for glob expansion" "$_glob_posix_n" "$_glob_fortsh_n"; fi
 +_glob_shell_n=$(printf '%s' "$_glob_shell" | normalize_output)
 +if [ "$_glob_posix_n" = "$_glob_shell_n" ]; then pass "for glob expansion"
 +else fail "for glob expansion" "$_glob_posix_n" "$_glob_shell_n"; fi
  compare_posix_output "for preserves IFS" "IFS=:; for i in a b c; do echo \$i; done; echo \$IFS | od -A n -t x1 | grep -c 3a"
  # ============================================================================

suites/posix/posix_gaps_heredoc.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_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
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; shell_code=$?
 +    if [ "$posix_code" = "$shell_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $shell_code"; fi
+ }
  # ============================================================================

suites/posix/posix_gaps_quoting.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  # ============================================================================

suites/posix/posix_gaps_redirect.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$shell_out"; fi
+ }
  compare_posix_exit_code() {
      test_name="$1"; command="$2"
      "$BASH_REF" -c "$command" >/dev/null 2>&1; posix_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
 +    "$SHELL_BIN" -c "$command" >/dev/null 2>&1; shell_code=$?
 +    if [ "$posix_code" = "$shell_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $shell_code"; fi
+ }
  # ============================================================================

suites/posix/posix_gaps_special.shmodified

  SHELL_BIN="${SHELL_BIN:?ERROR: SHELL_BIN must be set}"
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
      printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
      FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
      if [ -n "$2" ]; then printf "  posix:  %s\n" "$2"; fi
 -    if [ -n "$3" ]; then printf "  fortsh: %s\n" "$3"; fi
 +    if [ -n "$3" ]; then printf "  shell: %s\n" "$3"; fi
      FAILED=$((FAILED + 1))
+ }
      printf "\n${BLUE}==========================================\n%s\n==========================================${NC}\n" "$1"
+ }
 -normalize_output() { sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'; }
 +normalize_output() { sed -e 's|^[^ ]*/[a-z]*sh[0-9]*: |sh: |' -e 's|^[a-z]*sh[0-9]*: |sh: |' -e 's/line [0-9]*: //'; }
  compare_posix_output() {
      test_name="$1"; command="$2"
      posix_out=$("$BASH_REF" -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"
 +    shell_out=$("$SHELL_BIN" -c "$command" 2>&1 | normalize_output)
 +    if [ "$posix_out" = "$shell_out" ]; then pass "$test_name"
      else
 -        fail "$test_name" "$posix_out" "$fortsh_out"
 +        fail "$test_name" "$posix_out" "$shell_out"
          # Accumulate debug for CI summary
          DEBUG_INFO="${DEBUG_INFO}DEBUG [$test_name]: cmd='$command'\n"
          DEBUG_INFO="${DEBUG_INFO}  bash: '${posix_out}' hex=$(printf '%s' "$posix_out" | od -A x -t x1z | head -1)\n"
 -        DEBUG_INFO="${DEBUG_INFO}  fortsh: '${fortsh_out}' hex=$(printf '%s' "$fortsh_out" | od -A x -t x1z | head -1)\n"
 +        DEBUG_INFO="${DEBUG_INFO}  shell: '${shell_out}' hex=$(printf '%s' "$shell_out" | od -A x -t x1z | head -1)\n"
      fi
+ }

suites/posix/run_posix_tests.shmodified

  # =====================================
  # POSIX Compliance Test Runner
  # =====================================
 -# Runs all POSIX compliance test suites for fortsh
 +# Runs all POSIX compliance test suites for shell
  # Automatically detects fortsh binary location
  set -e

suites/test_harness.shmodified

  # macOS ships bash 3.2 which lacks these; override with BASH_REF=/opt/homebrew/bin/bash
  BASH_REF="${BASH_REF:-bash}"
 -# Check if fortsh exists
 +# Check if shell binary exists
  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"
  # Normalize shell name prefixes in error messages for comparison
  normalize_shell_name() {
 -    printf '%s\n' "$1" | sed -e 's/bash: line [0-9]*: /SHELL: /g' \
 -                              -e 's/fortsh: line [0-9]*: /SHELL: /g' \
 -                              -e 's/bash: /SHELL: /g' \
 -                              -e 's/fortsh: /SHELL: /g'
 +    printf '%s\n' "$1" | sed -e 's/[a-z]*sh[0-9]*: line [0-9]*: /SHELL: /g' \
 +                              -e  \
 +                              -e 's/[a-z]*sh[0-9]*: /SHELL: /g' \
 +                              -e 's/[a-z]*sh[0-9]*: /SHELL: /g'
+ }
  # Per-test timeout (seconds) — prevents hanging tests from blocking CI