`8b63983`

extract POSIX compliance shell scripts

17 posix_compliance_*.sh + 8 posix_gaps_*.sh + run_posix_tests.sh
~19,450 lines, ~3800 test assertions.

Verbatim copies. FORTSH_BIN references will be replaced in Phase 4.

Source: fortsh/tests/posix_*.sh, fortsh/tests/run_posix_tests.sh

Authored by

espadonne 1 month ago

SHA: 8b639836127f329b5b96162c873cb3fd71f02296
Parents: 431107b
Tree: f757358

26 changed files

Status	File	+
A	`suites/posix/posix_compliance_advanced.sh`	621
A	`suites/posix/posix_compliance_builtins.sh`	658
A	`suites/posix/posix_compliance_charclass.sh`	407
A	`suites/posix/posix_compliance_control.sh`	1326
A	`suites/posix/posix_compliance_coverage.sh`	480
A	`suites/posix/posix_compliance_extended.sh`	682
A	`suites/posix/posix_compliance_filetest.sh`	1108
A	`suites/posix/posix_compliance_gaps.sh`	2802
A	`suites/posix/posix_compliance_heredoc.sh`	758
A	`suites/posix/posix_compliance_jobcontrol.sh`	258
A	`suites/posix/posix_compliance_options.sh`	1248
A	`suites/posix/posix_compliance_printf.sh`	428
A	`suites/posix/posix_compliance_quoting.sh`	959
A	`suites/posix/posix_compliance_redirect.sh`	950
A	`suites/posix/posix_compliance_special.sh`	1396
A	`suites/posix/posix_compliance_test.sh`	448
A	`suites/posix/posix_compliance_untested.sh`	282
A	`suites/posix/posix_gaps_arithmetic.sh`	169
A	`suites/posix/posix_gaps_builtins.sh`	351
A	`suites/posix/posix_gaps_charclass.sh`	162
A	`suites/posix/posix_gaps_control.sh`	256
A	`suites/posix/posix_gaps_heredoc.sh`	161
A	`suites/posix/posix_gaps_quoting.sh`	127
A	`suites/posix/posix_gaps_redirect.sh`	156
A	`suites/posix/posix_gaps_special.sh`	225
A	`suites/posix/run_posix_tests.sh`	118

suites/posix/posix_compliance_advanced.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Advanced Test Suite for fortsh
 +# =====================================
 +# Additional coverage based on OpenGroup POSIX.1-2017 specification
 +# Fills gaps not covered in basic, extended, and builtins test suites
 +#
 +# Coverage areas:
 +# - Advanced control flow (break/continue with levels)
 +# - Additional special built-ins (exec, command)
 +# - Extended set options (-f, -x, -v, -a)
 +# - File descriptor operations
 +# - Advanced arithmetic operators
 +# - Signal handling extensions
 +# - Pathname expansion edge cases
 +# - IFS edge cases
 +# - Function recursion and advanced usage
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-advanced]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "51. BREAK CONTINUE"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# 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]*: //'
 +}
++
 +# Helper function to run command in both shells and compare
 +compare_posix_output() {
 +    test_name="$1"
 +    command="$2"
 +    posix_file="/tmp/posix_adv_$$_posix"
 +    fortsh_file="/tmp/posix_adv_$$_fortsh"
++
 +    # Run in POSIX shell (sh)
 +    "$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
++
 +    # Compare outputs
 +    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +    fi
++
 +    rm -f "$posix_file" "$fortsh_file"
 +}
++
 +# Helper function to compare exit codes
 +compare_posix_exit_code() {
 +    test_name="$1"
 +    command="$2"
++
 +    "$BASH_REF" -c "$command" > /dev/null 2>&1
 +    posix_exit=$?
++
 +    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    fortsh_exit=$?
++
 +    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +    fi
 +}
++
 +# Cleanup
 +cleanup() {
 +    rm -f /tmp/posix_adv_$$_* 2>/dev/null
 +    rm -rf /tmp/posix_advanced_test_* 2>/dev/null
 +}
 +trap cleanup EXIT INT TERM
++
 +section "51. BREAK AND CONTINUE IN LOOPS"
++
 +compare_posix_output "break in for loop" 'for i in 1 2 3 4 5; do echo $i; if [ $i -eq 3 ]; then break; fi; done'
 +compare_posix_output "continue in for loop" 'for i in 1 2 3 4 5; do if [ $i -eq 3 ]; then continue; fi; echo $i; done'
 +compare_posix_output "break in while loop" 'i=0; while [ $i -lt 5 ]; do i=$((i+1)); echo $i; if [ $i -eq 3 ]; then break; fi; done'
 +compare_posix_output "continue in while loop" 'i=0; while [ $i -lt 5 ]; do i=$((i+1)); if [ $i -eq 3 ]; then continue; fi; echo $i; done'
 +compare_posix_output "break in until loop" 'i=0; until [ $i -ge 5 ]; do i=$((i+1)); echo $i; if [ $i -eq 3 ]; then break; fi; done'
++
 +section "52. NESTED LOOPS WITH BREAK/CONTINUE"
++
 +compare_posix_output "break inner loop" 'for i in 1 2; do for j in a b c; do echo $i$j; if [ $j = b ]; then break; fi; done; done'
 +compare_posix_output "break with level" 'for i in 1 2; do for j in a b; do echo $i$j; if [ $j = b ]; then break 2; fi; done; done'
 +compare_posix_output "continue outer loop" 'for i in 1 2 3; do for j in a b; do echo $i$j; if [ $j = a ]; then continue 2; fi; done; done'
++
 +section "53. EXEC BUILTIN"
++
 +compare_posix_output "exec with redirect" 'exec 3>&1; echo test >&3; exec 3>&-; echo done'
 +compare_posix_exit_code "exec replace shell" '(exec true); echo $?'
 +compare_posix_output "exec without command" 'exec 2>&1; pwd >/dev/null'
++
 +section "54. COMMAND BUILTIN"
++
 +compare_posix_output "command -v test" 'command -v test | grep -c test'
 +compare_posix_output "command -v echo" 'command -v echo | grep -c echo'
 +compare_posix_exit_code "command -v nonexistent" '! command -v nonexistent_cmd_xyz'
++
 +section "55. READ BUILTIN - THOROUGH TESTING"
++
 +compare_posix_output "read single var" 'echo hello | read VAR 2>/dev/null || VAR=hello; echo $VAR'
 +compare_posix_output "read multiple vars" 'echo one two three | { read A B C; echo $A $B $C; }'
 +compare_posix_output "read with IFS" 'IFS=:; echo a:b:c | { read X Y Z; echo $X $Y $Z; }'
 +compare_posix_output "read remaining to last" 'echo a b c d e | { read X Y Z; echo "$Z"; }'
++
 +section "56. FILE DESCRIPTOR DUPLICATION"
++
 +compare_posix_output "dup stdout to fd3" 'exec 3>&1; echo test >&3'
 +compare_posix_output "dup stdin from fd" 'exec 3</dev/null; cat <&3; exec 3<&-; echo ok'
 +compare_posix_exit_code "close stdout" '(exec 1>&-; echo test 2>/dev/null); echo $?'
++
 +section "57. SET -F (NOGLOB)"
++
 +compare_posix_output "noglob disables expansion" 'set -f; echo /tmp/*.xyz; set +f'
 +compare_posix_output "noglob with literal star" 'set -f; VAR="a * b"; echo $VAR; set +f'
 +compare_posix_output "glob after set +f" 'set -f; set +f; echo /tmp 2>/dev/null | grep -c tmp'
++
 +section "58. SET -X (XTRACE)"
++
 +compare_posix_output "xtrace shows commands" 'set -x; echo test 2>/tmp/xtrace_$$; set +x; grep -c echo /tmp/xtrace_$$; rm -f /tmp/xtrace_$$'
 +compare_posix_output "xtrace in function" 'f() { set -x; echo inner 2>/tmp/xtrace_fn_$$; set +x; }; f; grep -c echo /tmp/xtrace_fn_$$; rm -f /tmp/xtrace_fn_$$'
++
 +section "59. SET -V (VERBOSE)"
++
 +compare_posix_output "verbose shows input" 'set -v; : test 2>&1 | grep -c test; set +v'
++
 +section "60. SET -A (ALLEXPORT)"
++
 +compare_posix_output "allexport exports vars" 'set -a; TEST_VAR=value; sh -c "echo \$TEST_VAR"'
 +compare_posix_output "allexport off" 'set +a; TEST2=val; sh -c "echo \${TEST2:-empty}"'
++
 +section "61. TRAP WITH SIGNALS"
++
 +compare_posix_output "trap INT signal" 'trap "echo caught" INT; trap | grep INT'
 +compare_posix_output "trap TERM signal" 'trap "echo term" TERM; trap | grep TERM'
 +compare_posix_output "trap HUP signal" 'trap "echo hup" HUP; trap | grep HUP'
 +compare_posix_output "trap with number" 'trap "echo sig15" 15; trap | grep -c 15'
++
 +section "62. TRAP INHERITANCE IN SUBSHELLS"
++
 +compare_posix_output "trap not inherited" 'trap "echo parent" EXIT; (trap | grep -c EXIT || echo 0)'
 +compare_posix_output "subshell can set trap" '(trap "echo sub" EXIT; exit 0)'
++
 +section "63. PARAMETER EXPANSION :? ERROR"
++
 +compare_posix_exit_code "error if unset" 'unset VAR; echo ${VAR:?error} 2>/dev/null'
 +compare_posix_exit_code "error if null" 'VAR=; echo ${VAR:?null} 2>/dev/null'
 +compare_posix_output "no error if set" 'VAR=test; echo ${VAR:?error}'
++
 +section "64. PARAMETER EXPANSION WITH SPECIAL PARAMS"
++
 +compare_posix_output "length of positional params" 'set -- a b c; echo ${#@}'
 +compare_posix_output "length of $*" 'set -- x y; echo ${#*}'
 +compare_posix_output "length of $1" 'set -- hello; echo ${#1}'
++
 +section "65. WAIT WITH ARGUMENTS"
++
 +compare_posix_output "wait specific PID" 'sleep 0.1 & pid=$!; wait $pid; echo $?'
 +compare_posix_output "wait all background" '(sleep 0.1 &); wait; echo ok'
 +compare_posix_exit_code "wait nonexistent PID" 'wait 999999'
++
 +section "66. IFS EDGE CASES"
++
 +compare_posix_output "empty IFS" 'IFS=; VAR="a b c"; set -- $VAR; echo $#'
 +compare_posix_output "IFS whitespace only" 'IFS=" \t\n"; VAR="a  b"; set -- $VAR; echo $# $1 $2'
 +compare_posix_output "IFS custom delimiter" 'IFS=,; VAR="a,b,c"; set -- $VAR; echo $2'
 +compare_posix_output "IFS leading delimiters" 'IFS=:; VAR=":a:b"; set -- $VAR; echo $#'
++
 +section "67. ARITHMETIC BITWISE OPERATORS"
++
 +compare_posix_output "bitwise AND" 'echo $((12 & 10))'
 +compare_posix_output "bitwise OR" 'echo $((12 | 10))'
 +compare_posix_output "bitwise XOR" 'echo $((12 ^ 10))'
 +compare_posix_output "bitwise NOT" 'echo $((~5))'
 +compare_posix_output "left shift" 'echo $((3 << 2))'
 +compare_posix_output "right shift" 'echo $((12 >> 2))'
++
 +section "68. ARITHMETIC ASSIGNMENT OPERATORS"
++
 +compare_posix_output "add assign" 'X=5; echo $((X += 3)); echo $X'
 +compare_posix_output "subtract assign" 'X=10; echo $((X -= 3)); echo $X'
 +compare_posix_output "multiply assign" 'X=4; echo $((X *= 2)); echo $X'
 +compare_posix_output "divide assign" 'X=20; echo $((X /= 4)); echo $X'
 +compare_posix_output "modulo assign" 'X=17; echo $((X %= 5)); echo $X'
++
 +section "69. ARITHMETIC INCREMENT/DECREMENT"
++
 +compare_posix_output "post increment" 'X=5; echo $((X++)); echo $X'
 +compare_posix_output "pre increment" 'X=5; echo $((++X)); echo $X'
 +compare_posix_output "post decrement" 'X=5; echo $((X--)); echo $X'
 +compare_posix_output "pre decrement" 'X=5; echo $((--X)); echo $X'
++
 +section "70. ARITHMETIC TERNARY OPERATOR"
++
 +compare_posix_output "ternary true" 'echo $((5 > 3 ? 10 : 20))'
 +compare_posix_output "ternary false" 'echo $((5 < 3 ? 10 : 20))'
 +compare_posix_output "ternary nested" 'echo $((1 ? 2 : 3 ? 4 : 5))'
++
 +section "71. PIPELINE NEGATION"
++
 +compare_posix_exit_code "negate true" '! true'
 +compare_posix_exit_code "negate false" '! false'
 +compare_posix_output "negate pipeline" '! echo test | grep -q xyz; echo $?'
 +compare_posix_exit_code "negate compound" '! (exit 0)'
++
 +section "72. THREE-STAGE PIPELINES"
++
 +compare_posix_output "three stage pipe" 'echo abc | tr a A | tr b B'
 +compare_posix_output "four stage pipe" 'echo test | cat | cat | wc -l'
 +compare_posix_exit_code "multi-stage exit" 'true | true | true'
++
 +section "73. CDPATH VARIABLE"
++
 +compare_posix_output "CDPATH usage" 'mkdir -p /tmp/posix_cdpath_test/subdir; CDPATH=/tmp/posix_cdpath_test; (cd subdir 2>/dev/null && pwd) | grep -c subdir; rm -rf /tmp/posix_cdpath_test'
++
 +section "74. OLDPWD VARIABLE"
++
 +compare_posix_output "OLDPWD set" 'OLD=/tmp; cd /tmp >/dev/null; cd / >/dev/null; echo $OLDPWD | grep -c tmp'
 +compare_posix_output "cd - uses OLDPWD" 'cd /tmp >/dev/null; cd / >/dev/null; cd - >/dev/null; pwd | grep -c tmp'
++
 +section "75. PATHNAME EXPANSION - BRACKET EXPRESSIONS"
++
 +mkdir -p /tmp/posix_advanced_test_bracket
 +touch /tmp/posix_advanced_test_bracket/a1.txt /tmp/posix_advanced_test_bracket/a2.txt
 +touch /tmp/posix_advanced_test_bracket/b1.txt /tmp/posix_advanced_test_bracket/b2.txt
 +touch /tmp/posix_advanced_test_bracket/c1.txt
++
 +compare_posix_output "bracket range" 'ls /tmp/posix_advanced_test_bracket/[a-b]1.txt 2>/dev/null | wc -l'
 +compare_posix_output "bracket negation" 'ls /tmp/posix_advanced_test_bracket/[!a]*.txt 2>/dev/null | wc -l'
 +compare_posix_output "bracket char class" 'ls /tmp/posix_advanced_test_bracket/[[:lower:]]1.txt 2>/dev/null | wc -l'
++
 +rm -rf /tmp/posix_advanced_test_bracket
++
 +section "76. PATHNAME EXPANSION - DOTFILE MATCHING"
++
 +mkdir -p /tmp/posix_advanced_test_dotfile
 +touch /tmp/posix_advanced_test_dotfile/.hidden
 +touch /tmp/posix_advanced_test_dotfile/visible
++
 +compare_posix_output "star no dotfiles" 'ls /tmp/posix_advanced_test_dotfile/* 2>/dev/null | wc -l'
 +compare_posix_output "explicit dot match" 'ls /tmp/posix_advanced_test_dotfile/.* 2>/dev/null | grep -c hidden'
++
 +rm -rf /tmp/posix_advanced_test_dotfile
++
 +section "77. FOR LOOP VARIATIONS"
++
 +compare_posix_output "for with glob" 'touch /tmp/posix_for_1.txt /tmp/posix_for_2.txt /tmp/posix_for_3.txt; for f in /tmp/posix_for_*.txt; do echo $f; done | wc -l; rm /tmp/posix_for_*.txt'
 +compare_posix_output "for with no items" 'for x in; do echo $x; done; echo empty'
 +compare_posix_output "for with quoted items" 'for i in "a b" "c d"; do echo $i; done | wc -l'
++
 +section "78. CASE PATTERN MATCHING"
++
 +compare_posix_output "case multiple pattern" 'x=b; case $x in a|b|c) echo match;; *) echo no;; esac'
 +compare_posix_output "case glob pattern" 'x=hello; case $x in h*) echo prefix;; esac'
 +compare_posix_output "case question mark" 'x=ab; case $x in ??) echo two;; esac'
 +compare_posix_output "case bracket" 'x=a; case $x in [abc]) echo bracket;; esac'
++
 +section "79. FUNCTION VARIATIONS"
++
 +compare_posix_output "function recursion" 'fact() { if [ $1 -le 1 ]; then echo 1; else echo $(($1 * $(fact $(($1 - 1))))); fi; }; fact 5'
 +compare_posix_output "function unset" 'f() { echo test; }; f; unset -f f; command -v f >/dev/null 2>&1; echo $?'
 +compare_posix_output "nested return" 'a() { b; echo $?; }; b() { return 42; }; a'
++
 +section "80. EXPANSION IN DIFFERENT CONTEXTS"
++
 +compare_posix_output "tilde in assignment" 'VAR=~; echo $VAR | grep -c ^/'
 +compare_posix_output "expansion in case" 'VAR=test; case $VAR in test) echo match;; esac'
 +compare_posix_output "no expansion in quotes" 'echo "~" | grep -c "~"'
++
 +section "81. REDIRECTION ORDER AND PRECEDENCE"
++
 +compare_posix_output "multiple redirects" 'echo test >/tmp/redir1 2>&1 >/tmp/redir2; cat /tmp/redir1 /tmp/redir2 2>/dev/null | wc -l; rm -f /tmp/redir1 /tmp/redir2'
 +compare_posix_output "redirect compound cmd" '{ echo a; echo b; } >/tmp/redir_compound; wc -l < /tmp/redir_compound; rm -f /tmp/redir_compound'
++
 +section "82. ERROR HANDLING IN EXPANSIONS"
++
 +compare_posix_exit_code "division by zero" 'echo $((5 / 0)) 2>/dev/null'
 +compare_posix_exit_code "expansion error" 'set -u; echo $UNDEFINED_VAR_XYZ 2>/dev/null'
++
 +section "83. SPECIAL PARAMETERS - ADDITIONAL"
++
 +compare_posix_output "PPID is numeric" 'echo $PPID | grep -c "^[0-9]*$"'
 +compare_posix_output "LINENO exists" 'echo $LINENO | grep -c "^[0-9]*$"'
++
 +section "84. ALIAS AND UNALIAS"
++
 +compare_posix_output "alias definition" 'alias ll="ls -l"; alias ll | grep -c "ls -l"'
 +compare_posix_output "unalias removes" 'alias test_alias=echo; unalias test_alias; alias test_alias 2>&1 | grep -c "not found"'
++
 +section "85. HASH BUILTIN OPERATIONS"
++
 +compare_posix_output "hash -r clears" 'hash -r; echo $?'
 +compare_posix_exit_code "hash command" 'hash echo 2>/dev/null'
++
 +section "86. MULTIPLE SEMICOLONS AND EDGE CASES"
++
 +compare_posix_output "multiple semicolons" 'echo a;; echo b'
 +compare_posix_output "semicolon at start" '; echo test'
 +compare_posix_exit_code "empty command" ''
++
 +section "87. BACKSLASH LINE CONTINUATION"
++
 +compare_posix_output "backslash continuation" 'echo hel\
 +lo'
 +compare_posix_output "backslash in command" 'ec\
 +ho test'
++
 +section "88. COMMENT HANDLING"
++
 +compare_posix_output "comment after command" 'echo visible # this is comment'
 +compare_posix_output "comment alone" '# comment
 +echo after'
++
 +section "89. QUOTING EDGE CASES"
++
 +compare_posix_output "empty string quotes" 'echo "" | wc -l'
 +compare_posix_output "adjacent quotes" 'echo "a"b"c"'
 +compare_posix_output "quote within quote" "echo \"it's\" | grep -c \"'\""
++
 +section "90. COMPOUND COMMAND REDIRECTION"
++
 +compare_posix_output "subshell with redirect" '(echo a; echo b) | wc -l'
 +compare_posix_output "brace group redirect" '{ echo x; echo y; } | wc -l'
 +compare_posix_output "if statement redirect" 'if true; then echo yes; fi | cat'
++
 +section "91. POSIX PARAMETER LENGTH"
++
 +compare_posix_output "length of empty" 'X=""; echo ${#X}'
 +compare_posix_output "length with spaces" 'X="a b c"; echo ${#X}'
 +compare_posix_output "length special chars" 'X="$@#!"; echo ${#X}'
 +compare_posix_output "length unicode" 'X="abc"; echo ${#X}'
++
 +section "92. POSIX DEFAULT VALUES VARIANTS"
++
 +compare_posix_output ":-colon vs dash" 'X=""; echo "${X:-default}" "${X-default}"'
 +compare_posix_output ":=colon vs equals" 'unset Y; echo "${Y:=def}"; echo $Y'
 +compare_posix_output ":+colon vs plus" 'X=val; echo "${X:+alt}" "${X+alt}"'
 +compare_posix_output ":?colon vs question" 'X=val; echo "${X:?err}" 2>/dev/null'
++
 +section "93. POSIX PATTERN REMOVAL EDGE CASES"
++
 +compare_posix_output "remove empty pattern" 'X=test; echo "${X#}"'
 +compare_posix_output "remove star pattern" 'X=test; echo "${X#*}"'
 +compare_posix_output "remove all with ##" 'X=test; echo "${X##*}"'
 +compare_posix_output "suffix empty" 'X=test; echo "${X%}"'
 +compare_posix_output "suffix star" 'X=test; echo "${X%*}"'
 +compare_posix_output "suffix all" 'X=test; echo "${X%%*}"'
++
 +section "94. POSIX ARITHMETIC OPERATORS"
++
 +compare_posix_output "arithmetic modulo" 'echo $((17 % 5))'
 +compare_posix_output "arithmetic negative" 'echo $((-5 + 3))'
 +compare_posix_output "arithmetic parens" 'echo $(((2 + 3) * 4))'
 +compare_posix_output "arithmetic bitwise and" 'echo $((12 & 10))'
 +compare_posix_output "arithmetic bitwise or" 'echo $((12 | 10))'
 +compare_posix_output "arithmetic bitwise xor" 'echo $((12 ^ 10))'
 +compare_posix_output "arithmetic shift left" 'echo $((1 << 4))'
 +compare_posix_output "arithmetic shift right" 'echo $((16 >> 2))'
++
 +section "95. POSIX ARITHMETIC COMPARISONS"
++
 +compare_posix_output "arith less than" 'echo $((3 < 5))'
 +compare_posix_output "arith greater than" 'echo $((5 > 3))'
 +compare_posix_output "arith less equal" 'echo $((3 <= 3))'
 +compare_posix_output "arith greater equal" 'echo $((3 >= 3))'
 +compare_posix_output "arith equal" 'echo $((5 == 5))'
 +compare_posix_output "arith not equal" 'echo $((5 != 3))'
 +compare_posix_output "arith logical and" 'echo $((1 && 1))'
 +compare_posix_output "arith logical or" 'echo $((0 || 1))'
++
 +section "96. POSIX COMMAND SUBSTITUTION EDGE CASES"
++
 +compare_posix_output "cmd sub with quotes" 'echo $(echo "hello world")'
 +compare_posix_output "cmd sub trailing newlines" 'echo "$(printf "a\n\n\n")"b'
 +compare_posix_output "cmd sub with pipe" 'echo $(echo test | tr t T)'
 +compare_posix_output "cmd sub with redirect" 'echo $(cat </dev/null)'
 +compare_posix_output "backtick with quotes" 'echo `echo "hello"`'
++
 +section "97. POSIX SUBSHELL VARIABLE ISOLATION"
++
 +compare_posix_output "subshell no export" 'X=1; (X=2; echo $X); echo $X'
 +compare_posix_output "subshell unset" 'X=1; (unset X; echo ${X:-empty}); echo $X'
 +# Note: (( expr )) is arithmetic syntax in bash, not nested subshell. Compare exit codes.
 +compare_posix_exit_code "double paren arithmetic" '(( echo nested ))'
 +compare_posix_output "subshell exit" '(exit 5); echo $?'
++
 +section "98. POSIX BRACE GROUP VS SUBSHELL"
++
 +compare_posix_output "brace group modifies" 'X=1; { X=2; }; echo $X'
 +compare_posix_output "subshell isolates" 'X=1; (X=2); echo $X'
 +compare_posix_output "brace with semicolon" '{ echo a; echo b; }'
 +compare_posix_output "brace in pipeline" '{ echo test; } | cat'
++
 +section "99. POSIX HERE-STRING ALTERNATIVES"
++
 +compare_posix_output "echo pipe vs redirect" 'echo test | cat'
 +compare_posix_output "printf to stdin" 'printf "test\n" | read X; echo $X'
++
 +section "100. POSIX PIPELINE EXIT STATUS"
++
 +compare_posix_output "pipe success" 'true | true; echo $?'
 +compare_posix_output "pipe last fails" 'true | false; echo $?'
 +compare_posix_output "pipe first fails" 'false | true; echo $?'
 +compare_posix_output "long pipeline" 'echo a | cat | cat | cat; echo $?'
++
 +section "101. POSIX PROCESS SUBSTITUTION ALTERNATIVES"
++
 +compare_posix_output "temp file pattern" 'echo test > /tmp/psub$$; cat /tmp/psub$$; rm /tmp/psub$$'
 +compare_posix_output "named pipe simulation" 'mkfifo /tmp/pfifo$$ 2>/dev/null || true; rm -f /tmp/pfifo$$; echo ok'
++
 +section "102. POSIX TEST BRACKETS"
++
 +compare_posix_output "test vs bracket" 'test 1 -eq 1 && [ 1 -eq 1 ] && echo ok'
 +compare_posix_output "bracket spacing" '[ "a" = "a" ] && echo match'
 +compare_posix_output "empty bracket test" '[ "" ] || echo empty'
 +compare_posix_output "nonempty test" '[ "x" ] && echo nonempty'
++
 +section "103. POSIX GETOPTS ADVANCED"
++
 +compare_posix_output "getopts multiple" 'while getopts "ab:c" opt 2>/dev/null; do echo $opt; done <<< "-a -b val -c"'
 +compare_posix_output "getopts OPTARG" 'getopts "a:" opt <<< "-a value" 2>/dev/null; echo $OPTARG'
 +compare_posix_output "getopts OPTIND" 'OPTIND=1; getopts "a" opt <<< "-a" 2>/dev/null; echo $OPTIND'
++
 +section "104. POSIX READ BUILTIN"
++
 +compare_posix_output "read single var" 'echo "hello" | { read X; echo $X; }'
 +compare_posix_output "read multiple vars" 'echo "a b c" | { read X Y Z; echo "$X:$Y:$Z"; }'
 +compare_posix_output "read with IFS" 'echo "a:b:c" | { IFS=: read X Y Z; echo "$X $Y $Z"; }'
 +compare_posix_output "read extra words" 'echo "a b c d" | { read X Y; echo "$X:$Y"; }'
++
 +section "105. POSIX PRINTF FORMATTING"
++
 +compare_posix_output "printf string" 'printf "%s\n" "test"'
 +compare_posix_output "printf integer" 'printf "%d\n" 42'
 +compare_posix_output "printf width" 'printf "%10s\n" "hi"'
 +compare_posix_output "printf left align" 'printf "%-10s|\n" "hi"'
 +compare_posix_output "printf zero pad" 'printf "%05d\n" 42'
 +compare_posix_output "printf multiple" 'printf "%s %d\n" "val" 123'
++
 +section "106. POSIX ARITHMETIC EDGE CASES"
++
 +compare_posix_output "unary minus" 'echo $((-5))'
 +compare_posix_output "unary plus" 'echo $((+5))'
 +compare_posix_output "double negative" 'echo $((--5))'
 +compare_posix_output "zero division check" 'echo $((5 / 1))'
 +compare_posix_output "modulo zero check" 'echo $((5 % 1))'
 +compare_posix_output "large number" 'echo $((1000000 * 1000))'
 +compare_posix_output "negative modulo" 'echo $((-7 % 3))'
 +compare_posix_output "chained ops" 'echo $((1 + 2 + 3 + 4 + 5))'
++
 +section "107. POSIX VARIABLE EDGE CASES"
++
 +compare_posix_output "underscore var" 'X_Y_Z=test; echo $X_Y_Z'
 +compare_posix_output "numeric suffix var" 'VAR1=a; VAR2=b; echo $VAR1$VAR2'
 +compare_posix_output "long var name" 'VERY_LONG_VARIABLE_NAME_HERE=val; echo $VERY_LONG_VARIABLE_NAME_HERE'
 +compare_posix_output "var with digits" 'A1B2C3=mix; echo $A1B2C3'
 +compare_posix_output "reassignment" 'X=1; X=2; X=3; echo $X'
 +compare_posix_output "self reference" 'X=a; X=${X}b; echo $X'
++
 +section "108. POSIX FUNCTION EDGE CASES"
++
 +compare_posix_output "function redefine" 'f() { echo first; }; f() { echo second; }; f'
 +compare_posix_output "function in pipeline" 'f() { echo test; }; f | cat'
 +compare_posix_output "function with subshell" 'f() { (echo sub); }; f'
 +compare_posix_output "function return in if" 'f() { if true; then return 0; fi; return 1; }; f; echo $?'
 +compare_posix_output "function shift" 'f() { shift; echo $1; }; f a b c'
 +compare_posix_output "function all args" 'f() { echo "$@"; }; f one two three'
++
 +section "109. POSIX LOOP EDGE CASES"
++
 +compare_posix_output "for single item" 'for i in single; do echo $i; done'
 +compare_posix_output "for many items" 'for i in 1 2 3 4 5 6 7 8 9 10; do echo $i; done | wc -l'
 +compare_posix_output "nested for" 'for i in a b; do for j in 1 2; do echo $i$j; done; done'
 +compare_posix_output "while nested" 'i=0; while [ $i -lt 2 ]; do j=0; while [ $j -lt 2 ]; do echo $i$j; j=$((j+1)); done; i=$((i+1)); done'
 +compare_posix_output "for with continue" 'for i in 1 2 3; do [ $i -eq 2 ] && continue; echo $i; done'
++
 +section "110. POSIX CASE EDGE CASES"
++
 +compare_posix_output "case empty pattern" 'x=; case "$x" in "") echo empty;; esac'
 +compare_posix_output "case glob star" 'x=anything; case $x in *) echo matched;; esac'
 +compare_posix_output "case multiple star" 'x=test; case $x in a*) echo a;; t*) echo t;; esac'
 +compare_posix_output "case bracket range" 'x=5; case $x in [0-9]) echo digit;; esac'
 +compare_posix_output "case no default" 'x=z; case $x in a) echo a;; b) echo b;; esac; echo done'
++
 +section "111. POSIX REDIRECTION EDGE CASES"
++
 +compare_posix_output "append create" 'rm -f /tmp/append_test_$$; echo first >> /tmp/append_test_$$; cat /tmp/append_test_$$; rm /tmp/append_test_$$'
 +compare_posix_output "redirect in loop" 'for i in 1 2 3; do echo $i; done > /tmp/loop_redir_$$; wc -l < /tmp/loop_redir_$$; rm /tmp/loop_redir_$$'
 +compare_posix_output "redirect in func" 'f() { echo test; }; f > /tmp/func_redir_$$; cat /tmp/func_redir_$$; rm /tmp/func_redir_$$'
 +compare_posix_output "multiple output" 'echo a > /tmp/multi1_$$; echo b > /tmp/multi2_$$; cat /tmp/multi1_$$ /tmp/multi2_$$; rm /tmp/multi1_$$ /tmp/multi2_$$'
++
 +section "112. POSIX PIPELINE EDGE CASES"
++
 +compare_posix_output "five stage pipe" 'echo test | cat | cat | cat | cat | cat'
 +compare_posix_output "pipe with grep" 'printf "a\nb\nc\n" | grep b'
 +compare_posix_output "pipe with wc" 'printf "a\nb\nc\n" | wc -l'
 +compare_posix_output "pipe with sort" 'printf "c\na\nb\n" | sort'
 +compare_posix_output "pipe with uniq" 'printf "a\na\nb\n" | uniq'
 +compare_posix_output "pipe with tr" 'echo abc | tr a-z A-Z'
++
 +section "113. POSIX SUBSHELL EDGE CASES"
++
 +compare_posix_output "subshell pwd" '(cd /tmp; pwd)'
 +compare_posix_output "subshell var" 'X=outer; (X=inner); echo $X'
 +compare_posix_output "subshell function" 'f() { echo hi; }; (f)'
 +compare_posix_output "subshell pipeline" '(echo a; echo b) | wc -l'
 +# Note: ((( expr ))) is arithmetic syntax in bash. Compare exit codes.
 +compare_posix_exit_code "triple paren arithmetic" '(((echo deep)))'
 +compare_posix_output "subshell arithmetic" '(echo $((2+2)))'
++
 +section "114. POSIX BRACE GROUP EDGE CASES"
++
 +compare_posix_output "brace simple" '{ echo test; }'
 +compare_posix_output "brace multi" '{ echo a; echo b; echo c; }'
 +compare_posix_output "brace var" 'X=1; { X=2; }; echo $X'
 +compare_posix_output "brace redirect" '{ echo test; } > /tmp/brace_$$; cat /tmp/brace_$$; rm /tmp/brace_$$'
 +compare_posix_output "brace in pipe" '{ echo a; echo b; } | wc -l'
++
 +section "115. POSIX SPECIAL CHAR EDGE CASES"
++
 +compare_posix_output "semicolon list" 'echo a; echo b; echo c'
 +compare_posix_output "ampersand bg" 'sleep 0.01 & wait; echo done'
 +compare_posix_output "double ampersand" 'true && echo yes'
 +compare_posix_output "double pipe" 'false || echo fallback'
 +compare_posix_output "mixed logic" 'true && true && echo all_true'
 +compare_posix_output "negation" '! false && echo negated'
++
 +# Summary
 +printf "\n"
 +printf "==========================================\n"
 +printf "ADVANCED POSIX COMPLIANCE TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +if [ $((PASSED + FAILED)) -gt 0 ]; then
 +    PASS_RATE=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%%\n" "$PASS_RATE"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL ADVANCED POSIX TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_compliance_builtins.shadded

 +#!/usr/bin/env bash
 +# ==============================================================================
 +# POSIX Compliance - Builtin Commands & Shell Options Test Suite
 +# ==============================================================================
 +# Tests all gaps identified in POSIX compliance analysis (2025-10-17)
 +# Covers: P0 (critical), P1 (important), P2 (nice-to-have) issues
 +# ==============================================================================
++
 +# Configuration
 +FORTSH_BIN="${FORTSH_BIN:-./bin/fortsh}"
 +VERBOSE="${VERBOSE:-0}"
++
 +# Test identification
 +TEST_PREFIX="[posix-builtins]"
++
 +# Test counters
 +TOTAL_TESTS=0
 +PASSED_TESTS=0
 +FAILED_TESTS=0
 +FAILED_TESTS_LIST=""
++
 +# Color codes (if terminal supports them)
 +if [ -t 1 ]; then
 +    RED='\033[0;31m'
 +    GREEN='\033[0;32m'
 +    YELLOW='\033[1;33m'
 +    BLUE='\033[0;34m'
 +    NC='\033[0m' # No Color
 +else
 +    RED=''
 +    GREEN=''
 +    YELLOW=''
 +    BLUE=''
 +    NC=''
 +fi
++
 +# Test result functions
 +pass() {
 +    PASSED_TESTS=$((PASSED_TESTS + 1))
 +    TOTAL_TESTS=$((TOTAL_TESTS + 1))
 +    echo -e "${GREEN}✓${NC} ${TEST_PREFIX} $1"
 +}
++
 +fail() {
 +    FAILED_TESTS=$((FAILED_TESTS + 1))
 +    TOTAL_TESTS=$((TOTAL_TESTS + 1))
 +    echo -e "${RED}✗${NC} ${TEST_PREFIX} $1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_PREFIX} $1\n"
 +    if [ "$VERBOSE" = "1" ]; then
 +        echo -e "${RED}  Details: $2${NC}"
 +    fi
 +}
++
 +section() {
 +    echo ""
 +    echo -e "${BLUE}========================================${NC}"
 +    echo -e "${BLUE}$1${NC}"
 +    echo -e "${BLUE}========================================${NC}"
 +}
++
 +# ==============================================================================
 +# P0: CRITICAL TESTS (Must pass for basic POSIX compliance)
 +# ==============================================================================
++
 +test_p0_readonly_enforcement() {
 +    section "P0-1: readonly Variable Enforcement"
++
 +    # Test 1: Cannot modify readonly variable
 +    output=$($FORTSH_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
 +        fail "P0-1.1: Readonly violation produces error message" "No error message found"
 +    fi
++
 +    # Test 2: Exit code is 1 for readonly violation (bash compatibility)
 +    $FORTSH_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
 +        fail "P0-1.2: Readonly violation returns exit code 1" "Got exit code $?"
 +    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)
 +    if ! echo "$output" | grep -q "SHOULD_NOT_PRINT"; then
 +        pass "P0-1.3: Commands after readonly violation do not execute"
 +    else
 +        fail "P0-1.3: Commands after readonly violation do not execute" "Command was executed"
 +    fi
++
 +    # Test 4: Readonly variable preserves original value (test removed - see P0-1.3)
 +    # Note: POSIX requires non-interactive shells to exit on readonly violations,
 +    # so we cannot test value preservation after failed assignment in same script.
 +    # 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
 +    if [ $? -eq 1 ]; then
 +        pass "P0-1.5: Multiple readonly violations handled correctly"
 +    else
 +        fail "P0-1.5: Multiple readonly violations handled correctly" "Got exit code $?"
 +    fi
 +}
++
 +test_p0_set_u() {
 +    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)
 +    if echo "$output" | grep -q "unbound variable"; then
 +        pass "P0-2.1: set -u detects undefined variable in \${VAR}"
 +    else
 +        fail "P0-2.1: set -u detects undefined variable in \${VAR}" "No error for undefined variable"
 +    fi
++
 +    # Test 2: Undefined variable in simple expansion
 +    output=$($FORTSH_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
 +        fail "P0-2.2: set -u detects undefined variable in \$VAR"
 +    fi
++
 +    # 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
 +    exit_code=$?
 +    output=$($FORTSH_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
 +        fail "P0-2.3: Non-interactive shell exits on unbound variable" "Exit code: $exit_code"
 +    fi
++
 +    # Test 4: Defined variable works with set -u
 +    output=$($FORTSH_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
 +        fail "P0-2.4: Defined variables work correctly with set -u"
 +    fi
++
 +    # Test 5: set +u disables the option
 +    output=$($FORTSH_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
 +        fail "P0-2.5: set +u correctly disables nounset option"
 +    fi
++
 +    # Test 6: Special variables always defined ($?, $$, etc.)
 +    output=$($FORTSH_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
 +        fail "P0-2.6: Special variables don't trigger set -u"
 +    fi
 +}
++
 +test_p0_trap_exit() {
 +    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)
 +    if echo "$output" | grep -q "TRAPPED"; then
 +        pass "P0-3.1: EXIT trap executes on exit builtin"
 +    else
 +        fail "P0-3.1: EXIT trap executes on exit builtin" "Trap did not execute"
 +    fi
++
 +    # Test 2: EXIT trap preserves exit code
 +    $FORTSH_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
 +        fail "P0-3.2: EXIT trap preserves original exit code" "Got exit code $?"
 +    fi
++
 +    # Test 3: EXIT trap executes on natural shell exit
 +    output=$(echo 'trap "echo CLEANUP" EXIT; echo done' | $FORTSH_BIN 2>&1)
 +    if echo "$output" | grep -q "CLEANUP"; then
 +        pass "P0-3.3: EXIT trap executes on natural shell termination"
 +    else
 +        fail "P0-3.3: EXIT trap executes on natural shell termination"
 +    fi
++
 +    # Test 4: EXIT trap executes only once
 +    output=$($FORTSH_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"
 +    else
 +        fail "P0-3.4: EXIT trap executes exactly once" "Executed $count times"
 +    fi
++
 +    # Test 5: EXIT trap can access variables
 +    output=$($FORTSH_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
 +        fail "P0-3.5: EXIT trap can access shell variables"
 +    fi
++
 +    # Test 6: EXIT trap with non-zero exit from command
 +    $FORTSH_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
 +        fail "P0-3.6: EXIT trap preserves command failure exit code"
 +    fi
 +}
++
 +# ==============================================================================
 +# P1: IMPORTANT TESTS (Correctness and error handling)
 +# ==============================================================================
++
 +test_p1_exit_code_126() {
 +    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
 +    $FORTSH_BIN -c '/tmp/fortsh_test_nonexec' >/dev/null 2>&1
 +    exit_code=$?
 +    rm -f /tmp/fortsh_test_nonexec
++
 +    if [ $exit_code -eq 126 ]; then
 +        pass "P1-1.1: Non-executable file returns exit code 126"
 +    else
 +        fail "P1-1.1: Non-executable file returns exit code 126" "Got exit code $exit_code"
 +    fi
++
 +    # Test 2: Non-existent file still returns 127
 +    $FORTSH_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
 +        fail "P1-1.2: Non-existent command returns exit code 127" "Got exit code $?"
 +    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
 +    $FORTSH_BIN -c '/tmp/fortsh_test_exec' >/dev/null 2>&1
 +    exit_code=$?
 +    rm -f /tmp/fortsh_test_exec
++
 +    if [ $exit_code -eq 5 ]; then
 +        pass "P1-1.3: Executable file returns its own exit code"
 +    else
 +        fail "P1-1.3: Executable file returns its own exit code" "Got exit code $exit_code"
 +    fi
 +}
++
 +test_p1_set_c_noclobber() {
 +    section "P1-2: set -C (noclobber option)"
++
 +    # 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
 +    exit_code=$?
 +    content=$(cat /tmp/fortsh_test_noclobber 2>/dev/null)
 +    rm -f /tmp/fortsh_test_noclobber
++
 +    if [ $exit_code -ne 0 ] && [ "$content" = "original" ]; then
 +        pass "P1-2.1: set -C prevents overwriting existing files"
 +    else
 +        fail "P1-2.1: set -C prevents overwriting existing files" "File was overwritten"
 +    fi
++
 +    # 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
 +    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
 +    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
 +    $FORTSH_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
++
 +    if [ "$content" = "forced" ]; then
 +        pass "P1-2.3: >| forces overwrite with noclobber set"
 +    else
 +        fail "P1-2.3: >| forces overwrite with noclobber set" "Content: $content"
 +    fi
++
 +    # 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
 +    content=$(cat /tmp/fortsh_test_disable 2>/dev/null)
 +    rm -f /tmp/fortsh_test_disable
++
 +    if [ "$content" = "new" ]; then
 +        pass "P1-2.4: set +C disables noclobber option"
 +    else
 +        fail "P1-2.4: set +C disables noclobber option"
 +    fi
 +}
++
 +test_p1_trap_removal() {
 +    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)
 +    if ! echo "$output" | grep -q "caught"; then
 +        pass "P1-3.1: trap - INT removes INT trap"
 +    else
 +        fail "P1-3.1: trap - INT removes INT trap" "Trap still executed"
 +    fi
++
 +    # Test 2: trap - TERM removes TERM trap
 +    $FORTSH_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
 +        fail "P1-3.2: trap - TERM removes TERM trap"
 +    fi
++
 +    # Test 3: trap - EXIT removes EXIT trap
 +    output=$($FORTSH_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
 +        fail "P1-3.3: trap - EXIT removes EXIT trap"
 +    fi
++
 +    # Test 4: Listing traps after removal
 +    output=$($FORTSH_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
 +        fail "P1-3.4: Removed traps don't appear in trap listing"
 +    fi
 +}
++
 +test_p1_set_e_conditionals() {
 +    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)
 +    if echo "$output" | grep -q "YES"; then
 +        pass "P1-4.1: set -e doesn't exit on false in if condition"
 +    else
 +        fail "P1-4.1: set -e doesn't exit on false in if condition"
 +    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)
 +    if echo "$output" | grep -q "AFTER"; then
 +        pass "P1-4.2: set -e doesn't exit on false in while condition"
 +    else
 +        fail "P1-4.2: set -e doesn't exit on false in while condition"
 +    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
 +    exit_code=$?
 +    if [ $exit_code -ne 0 ]; then
 +        pass "P1-4.3: set -e exits on command failure outside conditionals"
 +    else
 +        fail "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)
 +    if echo "$output" | grep -q "AFTER_OR"; then
 +        pass "P1-4.4: set -e doesn't exit on false before ||"
 +    else
 +        fail "P1-4.4: set -e doesn't exit on false before ||"
 +    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)
 +    if echo "$output" | grep -q "DONE"; then
 +        pass "P1-4.5: set -e doesn't exit on false in until condition"
 +    else
 +        fail "P1-4.5: set -e doesn't exit on false in until condition"
 +    fi
 +}
++
 +# ==============================================================================
 +# P2: NICE-TO-HAVE TESTS (Quality of life features)
 +# ==============================================================================
++
 +test_p2_background_pid() {
 +    section "P2-1: \$! (Background Process PID)"
++
 +    # Test 1: $! contains PID of last background job
 +    output=$($FORTSH_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
 +        fail "P2-1.1: \$! expands to numeric PID" "Got: $output"
 +    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)
 +    if echo "$output" | grep -q "DIFFERENT"; then
 +        pass "P2-1.2: \$! updates for each background job"
 +    else
 +        fail "P2-1.2: \$! updates for each background job" "Got: [$output]"
 +    fi
++
 +    # Test 3: $! is empty/zero before any background jobs
 +    output=$($FORTSH_BIN -c 'echo "|$!|"' 2>&1)
 +    if echo "$output" | grep -qE '\|[0-9]*\|'; then
 +        pass "P2-1.3: \$! has valid value before background jobs"
 +    else
 +        fail "P2-1.3: \$! has valid value before background jobs"
 +    fi
 +}
++
 +test_p2_dot_with_args() {
 +    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=$($FORTSH_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
 +        pass "P2-2.1: dot command passes arguments to sourced script"
 +    else
 +        fail "P2-2.1: dot command passes arguments to sourced script" "Got: $output"
 +    fi
++
 +    # 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)
 +    rm -f /tmp/fortsh_test_source2
++
 +    if echo "$output" | grep -q "from_script"; then
 +        pass "P2-2.2: Sourced script sets variables in caller"
 +    else
 +        fail "P2-2.2: Sourced script sets variables in caller"
 +    fi
++
 +    # Test 3: Source with absolute path
 +    echo 'echo sourced' > /tmp/fortsh_abs_source
 +    output=$($FORTSH_BIN -c '. /tmp/fortsh_abs_source' 2>&1)
 +    rm -f /tmp/fortsh_abs_source
++
 +    if echo "$output" | grep -q "sourced"; then
 +        pass "P2-2.3: dot command works with absolute paths"
 +    else
 +        fail "P2-2.3: dot command works with absolute paths"
 +    fi
 +}
++
 +test_p2_readonly_unset() {
 +    section "P2-3: Readonly Unset Prevention"
++
 +    # Test 1: Cannot unset readonly variable
 +    output=$($FORTSH_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
 +        fail "P2-3.1: unset readonly variable produces error"
 +    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)
 +    if echo "$output" | grep -q "value"; then
 +        pass "P2-3.2: Readonly variable survives unset attempt"
 +    else
 +        fail "P2-3.2: Readonly variable survives unset attempt"
 +    fi
++
 +    # Test 3: unset returns non-zero for readonly variables
 +    $FORTSH_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
 +        fail "P2-3.3: unset readonly variable returns non-zero"
 +    fi
++
 +    # Test 4: Can unset non-readonly variables
 +    output=$($FORTSH_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
 +        fail "P2-3.4: unset works for non-readonly variables"
 +    fi
 +}
++
 +# ==============================================================================
 +# ADDITIONAL ROBUSTNESS TESTS
 +# ==============================================================================
++
 +test_additional_builtins() {
 +    section "BONUS: Additional Builtin Tests"
++
 +    # Test shift builtin
 +    output=$($FORTSH_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
 +        fail "BONUS-1: shift builtin works correctly"
 +    fi
++
 +    # Test times builtin
 +    output=$($FORTSH_BIN -c 'times' 2>&1)
 +    if echo "$output" | grep -qE '[0-9]'; then
 +        pass "BONUS-2: times builtin produces output"
 +    else
 +        fail "BONUS-2: times builtin produces output"
 +    fi
++
 +    # Test hash builtin
 +    output=$($FORTSH_BIN -c 'hash' 2>&1)
 +    if [ $? -eq 0 ]; then
 +        pass "BONUS-3: hash builtin executes without error"
 +    else
 +        fail "BONUS-3: hash builtin executes without error"
 +    fi
++
 +    # Test type builtin
 +    output=$($FORTSH_BIN -c 'type echo' 2>&1)
 +    if echo "$output" | grep -qiE '(builtin|command)'; then
 +        pass "BONUS-4: type builtin identifies commands"
 +    else
 +        fail "BONUS-4: type builtin identifies commands"
 +    fi
++
 +    # Test umask builtin
 +    output=$($FORTSH_BIN -c 'umask' 2>&1)
 +    if echo "$output" | grep -qE '^[0-9]{4}$'; then
 +        pass "BONUS-5: umask builtin displays mask"
 +    else
 +        fail "BONUS-5: umask builtin displays mask"
 +    fi
++
 +    # Test getopts builtin
 +    output=$($FORTSH_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
 +        fail "BONUS-6: getopts builtin parses options"
 +    fi
 +}
++
 +test_edge_cases() {
 +    section "BONUS: Edge Cases"
++
 +    # Test empty command
 +    $FORTSH_BIN -c '' >/dev/null 2>&1
 +    if [ $? -eq 0 ]; then
 +        pass "EDGE-1: Empty command succeeds"
 +    else
 +        fail "EDGE-1: Empty command succeeds"
 +    fi
++
 +    # Test semicolon alone
 +    # POSIX: Semicolon alone is a syntax error (exit code 2), not success
 +    $FORTSH_BIN -c ';' >/dev/null 2>&1
 +    if [ $? -eq 2 ]; then
 +        pass "EDGE-2: Semicolon alone is syntax error"
 +    else
 +        fail "EDGE-2: Semicolon alone is syntax error" "Expected exit 2, got $?"
 +    fi
++
 +    # Test comment handling
 +    output=$($FORTSH_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
 +        fail "EDGE-3: Comments are ignored correctly"
 +    fi
++
 +    # Test multiple semicolons
 +    output=$($FORTSH_BIN -c 'echo a;; echo b' 2>&1)
 +    if echo "$output" | grep -q "b"; then
 +        pass "EDGE-4: Multiple semicolons handled"
 +    else
 +        fail "EDGE-4: Multiple semicolons handled"
 +    fi
 +}
++
 +# ==============================================================================
 +# MAIN TEST EXECUTION
 +# ==============================================================================
++
 +main() {
 +    echo "=========================================="
 +    echo "POSIX Compliance - Builtin Test Suite"
 +    echo "=========================================="
 +    echo "Testing: $FORTSH_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"
 +        exit 1
 +    fi
++
 +    # Run all test suites
 +    test_p0_readonly_enforcement
 +    test_p0_set_u
 +    test_p0_trap_exit
++
 +    test_p1_exit_code_126
 +    test_p1_set_c_noclobber
 +    test_p1_trap_removal
 +    test_p1_set_e_conditionals
++
 +    test_p2_background_pid
 +    test_p2_dot_with_args
 +    test_p2_readonly_unset
++
 +    test_additional_builtins
 +    test_edge_cases
++
 +    # Print summary
 +    echo ""
 +    echo "=========================================="
 +    echo "TEST SUMMARY ${TEST_PREFIX}"
 +    echo "=========================================="
 +    echo -e "Total Tests:  $TOTAL_TESTS"
 +    echo -e "${GREEN}Passed:       $PASSED_TESTS${NC}"
 +    echo -e "${RED}Failed:       $FAILED_TESTS${NC}"
++
 +    if [ $FAILED_TESTS -gt 0 ]; then
 +        echo ""
 +        echo -e "${RED}Failed tests:${NC}"
 +        echo -e "$FAILED_TESTS_LIST"
 +        echo "=========================================="
 +    fi
++
 +    if [ $FAILED_TESTS -eq 0 ]; then
 +        echo ""
 +        echo -e "${GREEN}=========================================="
 +        echo -e "✓ ALL TESTS PASSED!"
 +        echo -e "==========================================${NC}"
 +        exit 0
 +    else
 +        echo ""
 +        echo -e "${RED}=========================================="
 +        echo -e "✗ SOME TESTS FAILED"
 +        echo -e "==========================================${NC}"
 +        echo ""
 +        echo "Run with VERBOSE=1 for detailed failure information:"
 +        echo "  VERBOSE=1 $0"
 +        exit 1
 +    fi
 +}
++
 +# Run main function
 +main "$@"

suites/posix/posix_compliance_charclass.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Character Class Test Suite for fortsh
 +# =====================================
 +# Tests POSIX bracket expression character classes per IEEE Std 1003.1-2017
 +# Section 9.3.5 RE Bracket Expression
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-charclass]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Create test directory with test files
 +setup_test_files() {
 +    TEST_DIR="/tmp/fortsh_charclass_$$"
 +    mkdir -p "$TEST_DIR"
 +    cd "$TEST_DIR" || exit 1
++
 +    # Create files for character class testing
 +    touch "file1.txt" "file2.txt" "file3.txt"
 +    touch "FileA.txt" "FileB.txt" "FileC.txt"
 +    touch "data_01.csv" "data_02.csv" "data_99.csv"
 +    touch "test-file" "test_file" "test.file"
 +    touch "UPPER.TXT" "lower.txt" "MiXeD.TxT"
 +    touch "a1b2c3" "xyz789" "ABC123"
 +    touch "file with space.txt"
 +    touch ".hidden" ".dotfile"
 +    touch "special!file" "special@file"
 +}
++
 +cleanup_test_files() {
 +    cd /
 +    rm -rf "$TEST_DIR"
 +}
++
 +# Trap to ensure cleanup
 +trap cleanup_test_files EXIT
++
 +setup_test_files
++
 +# =====================================
 +section "341. POSIX CHARACTER CLASS [:alpha:]"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    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)
 +if [ -n "$result" ] && [ "$result" != '[[:alpha:]]*.txt' ]; then
 +    pass "[:alpha:] in loop context"
 +else
 +    fail "[:alpha:] in loop context" "matched files" "$result"
 +fi
++
 +# =====================================
 +section "342. POSIX CHARACTER CLASS [:digit:]"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -q "data_"; then
 +    pass "[:digit:][:digit:] matches two digits"
 +else
 +    fail "[:digit:][:digit:] matches two digits" "files ending in two digits" "$result"
 +fi
++
 +# =====================================
 +section "343. POSIX CHARACTER CLASS [:alnum:]"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:alnum:]]*.txt' 2>&1)
 +if echo "$result" | grep -q "file"; then
 +    pass "[:alnum:] matches alphanumeric characters"
 +else
 +    fail "[:alnum:] matches alphanumeric characters" "alphanumeric files" "$result"
 +fi
++
 +# =====================================
 +section "344. POSIX CHARACTER CLASS [:upper:]"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -q "UPPER.TXT\|ABC"; then
 +    pass "[:upper:] repeated matches multiple uppercase"
 +else
 +    fail "[:upper:] repeated matches multiple uppercase" "all-caps files" "$result"
 +fi
++
 +# =====================================
 +section "345. POSIX CHARACTER CLASS [:lower:]"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'cd '"$TEST_DIR"' && echo [[:lower:]]*.txt' 2>&1)
 +if echo "$result" | grep -q "file\|lower"; then
 +    pass "[:lower:] matches lowercase characters"
 +else
 +    fail "[:lower:] matches lowercase characters" "lowercase files" "$result"
 +fi
++
 +# =====================================
 +section "346. POSIX CHARACTER CLASS [:space:]"
 +# =====================================
++
 +# [:space:] in variable content
 +result=$("$FORTSH_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
 +    fail "[:space:] matches space in case pattern" "has space" "$result"
 +fi
++
 +# =====================================
 +section "347. POSIX CHARACTER CLASS [:blank:]"
 +# =====================================
++
 +# [:blank:] matches space and tab only
 +result=$("$FORTSH_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
 +    fail "[:blank:] matches tab character" "has blank" "$result"
 +fi
++
 +# =====================================
 +section "348. POSIX CHARACTER CLASS [:xdigit:]"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "valid hex" ]; then
 +    pass "[:xdigit:] matches uppercase hex"
 +else
 +    fail "[:xdigit:] matches uppercase hex" "valid hex" "$result"
 +fi
++
 +# =====================================
 +section "349. POSIX CHARACTER CLASS [:punct:]"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "starts with punct" ]; then
 +    pass "[:punct:] matches special characters"
 +else
 +    fail "[:punct:] matches special characters" "starts with punct" "$result"
 +fi
++
 +# =====================================
 +section "350. POSIX CHARACTER CLASS [:print:]"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'case "hello" in [[:print:]]*) echo "printable";; esac' 2>&1)
 +if [ "$result" = "printable" ]; then
 +    pass "[:print:] matches printable characters"
 +else
 +    fail "[:print:] matches printable characters" "printable" "$result"
 +fi
++
 +# =====================================
 +section "351. POSIX CHARACTER CLASS [:graph:]"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'case "abc123" in [[:graph:]]*) echo "graphical";; esac' 2>&1)
 +if [ "$result" = "graphical" ]; then
 +    pass "[:graph:] matches graphical characters"
 +else
 +    fail "[:graph:] matches graphical characters" "graphical" "$result"
 +fi
++
 +# =====================================
 +section "352. POSIX BRACKET NEGATION [^...] and [!...]"
 +# =====================================
++
 +# Note: POSIX uses [!...] for negation, [^...] is bash extension
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -q "file\|File"; then
 +    pass "[!...] negation matches non-digits"
 +else
 +    fail "[!...] negation matches non-digits" "non-digit files" "$result"
 +fi
++
 +# =====================================
 +section "353. POSIX RANGE EXPRESSIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if echo "$result" | grep -q "file\|lower"; then
 +    pass "[a-z] range matches lowercase"
 +else
 +    fail "[a-z] range matches lowercase" "lowercase files" "$result"
 +fi
++
 +# =====================================
 +section "354. COMBINED CHARACTER CLASSES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "matched" ]; then
 +    pass "Combined classes in exact pattern"
 +else
 +    fail "Combined classes in exact pattern" "matched" "$result"
 +fi
++
 +# =====================================
 +section "355. CHARACTER CLASS IN CASE STATEMENTS"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c '
 +for word in hello WORLD 123 test!; do
 +    case "$word" in
 +        [[:upper:]]*) echo "$word: upper" ;;
 +        [[:lower:]]*) echo "$word: lower" ;;
 +        [[:digit:]]*) echo "$word: digit" ;;
 +        *) echo "$word: other" ;;
 +    esac
 +done
 +' 2>&1)
 +if echo "$result" | grep -q "hello: lower" && echo "$result" | grep -q "WORLD: upper" && echo "$result" | grep -q "123: digit"; then
 +    pass "Character classes in case statement"
 +else
 +    fail "Character classes in case statement" "categorized output" "$result"
 +fi
++
 +# =====================================
 +section "356. CHARACTER CLASS EDGE CASES"
 +# =====================================
++
 +# Literal hyphen at start
 +result=$("$FORTSH_BIN" -c 'case "-test" in [-a]*) echo "matched";; esac' 2>&1)
 +if [ "$result" = "matched" ]; then
 +    pass "Literal hyphen at bracket start"
 +else
 +    fail "Literal hyphen at bracket start" "matched" "$result"
 +fi
++
 +# Literal bracket
 +result=$("$FORTSH_BIN" -c 'case "[test]" in \[*) echo "matched";; esac' 2>&1)
 +if [ "$result" = "matched" ]; then
 +    pass "Escaped bracket in pattern"
 +else
 +    fail "Escaped bracket in pattern" "matched" "$result"
 +fi
++
 +# Empty class should not match
 +result=$("$FORTSH_BIN" -c 'case "test" in []) echo "empty";; *) echo "star";; esac' 2>&1)
 +if [ "$result" = "star" ]; then
 +    pass "Empty bracket expression fallthrough"
 +else
 +    skip "Empty bracket expression fallthrough" "implementation varies"
 +fi
++
 +# =====================================
 +section "357. CHARACTER CLASS WITH GLOB PATTERNS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -q "file\|File\|lower"; then
 +    pass "Character class with ? wildcards"
 +else
 +    fail "Character class with ? wildcards" "pattern matched files" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Character Class Test Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_control.shadded

1326 lines changed — click to load

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Control Flow and Grouping Test Suite for fortsh
 +# =====================================
 +# Tests control flow, subshells, brace groups per IEEE Std 1003.1-2017
 +# Section: Shell Command Language - Compound Commands
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-control]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# =====================================
 +section "411. SUBSHELL EXECUTION ( )"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +expected=$(printf "inner\nouter")
 +if [ "$result" = "$expected" ]; then
 +    pass "Subshell variable isolation"
 +else
 +    fail "Subshell variable isolation" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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"
 +else
 +    fail "Subshell cd isolation" "/tmp then original" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +expected=$(printf "a\nb\nc")
 +if [ "$result" = "$expected" ]; then
 +    pass "Subshell with multiple commands"
 +else
 +    fail "Subshell with multiple commands" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "412. BRACE GROUP { }"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +expected=$(printf "inner\ninner")
 +if [ "$result" = "$expected" ]; then
 +    pass "Brace group shares variable scope"
 +else
 +    fail "Brace group shares variable scope" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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"
 +else
 +    fail "Brace group with multiple commands" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c '{ false; }; echo $?' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "Brace group exit status"
 +else
 +    fail "Brace group exit status" "1" "$result"
 +fi
++
 +# =====================================
 +section "413. BREAK WITH COUNT"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2 3; do
 +    for j in a b c; do
 +        if [ "$j" = "b" ]; then
 +            break
 +        fi
 +        echo "$i$j"
 +    done
 +done' 2>&1)
 +expected=$(printf "1a\n2a\n3a")
 +if [ "$result" = "$expected" ]; then
 +    pass "break exits inner loop"
 +else
 +    fail "break exits inner loop" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2 3; do
 +    for j in a b c; do
 +        if [ "$j" = "b" ]; then
 +            break 2
 +        fi
 +        echo "$i$j"
 +    done
 +done' 2>&1)
 +if [ "$result" = "1a" ]; then
 +    pass "break 2 exits both loops"
 +else
 +    fail "break 2 exits both loops" "1a" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2 3; do
 +    break
 +    echo "not reached"
 +done
 +echo "done"' 2>&1)
 +if [ "$result" = "done" ]; then
 +    pass "break stops loop immediately"
 +else
 +    fail "break stops loop immediately" "done" "$result"
 +fi
++
 +# =====================================
 +section "414. CONTINUE WITH COUNT"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2 3; do
 +    if [ "$i" = "2" ]; then
 +        continue
 +    fi
 +    echo $i
 +done' 2>&1)
 +expected=$(printf "1\n3")
 +if [ "$result" = "$expected" ]; then
 +    pass "continue skips iteration"
 +else
 +    fail "continue skips iteration" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2; do
 +    for j in a b c; do
 +        if [ "$j" = "b" ]; then
 +            continue 2
 +        fi
 +        echo "$i$j"
 +    done
 +    echo "inner done"
 +done' 2>&1)
 +expected=$(printf "1a\n2a")
 +if [ "$result" = "$expected" ]; then
 +    pass "continue 2 continues outer loop"
 +else
 +    fail "continue 2 continues outer loop" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "415. WHILE LOOP"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    fail "Basic while loop" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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 '
 +i=0
 +while [ $i -lt 5 ]; do
 +    i=$((i+1))
 +    if [ $i -eq 3 ]; then continue; fi
 +    echo $i
 +done' 2>&1)
 +expected=$(printf "1\n2\n4\n5")
 +if [ "$result" = "$expected" ]; then
 +    pass "While with continue"
 +else
 +    fail "While with continue" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "416. UNTIL LOOP"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    fail "Basic until loop" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'until true; do echo no; done; echo done' 2>&1)
 +if [ "$result" = "done" ]; then
 +    pass "Until with true condition"
 +else
 +    fail "Until with true condition" "done" "$result"
 +fi
++
 +# =====================================
 +section "417. PIPELINE EXIT STATUS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +expected=$(printf "hello\n0")
 +if [ "$result" = "$expected" ]; then
 +    pass "Multi-stage pipeline"
 +else
 +    fail "Multi-stage pipeline" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "418. AND-OR LISTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +expected=$(printf "a\nb")
 +if [ "$result" = "$expected" ]; then
 +    pass "Chained && operators"
 +else
 +    fail "Chained && operators" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "mixed" ]; then
 +    pass "Mixed && and ||"
 +else
 +    fail "Mixed && and ||" "mixed" "$result"
 +fi
++
 +# =====================================
 +section "419. NEGATION WITH !"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "1" ]; then
 +    pass "! negates command exit status"
 +else
 +    fail "! negates command exit status" "1" "$result"
 +fi
++
 +# =====================================
 +section "420. DOT (SOURCE) COMMAND"
 +# =====================================
++
 +TEST_DIR="/tmp/fortsh_control_$$"
 +mkdir -p "$TEST_DIR"
++
 +# Create a file to source
 +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)
 +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)
 +if echo "$result" | grep -q "from func"; then
 +    pass ". sources file and defines function"
 +else
 +    fail ". sources file and defines function" "from func" "$result"
 +fi
++
 +# 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)
 +if [ "$result" = "arg1=foo arg2=bar" ]; then
 +    pass ". passes arguments to sourced script"
 +else
 +    fail ". passes arguments to sourced script" "arg1=foo arg2=bar" "$result"
 +fi
++
 +rm -rf "$TEST_DIR"
++
 +# =====================================
 +section "421. EXEC BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'exec echo replaced' 2>&1)
 +if [ "$result" = "replaced" ]; then
 +    pass "exec replaces shell with command"
 +else
 +    fail "exec replaces shell with command" "replaced" "$result"
 +fi
++
 +# exec without command just does redirections
 +result=$("$FORTSH_BIN" -c 'exec 2>/dev/null; echo hello' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "exec without command continues shell"
 +else
 +    fail "exec without command continues shell" "hello" "$result"
 +fi
++
 +# =====================================
 +section "422. EVAL BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "42" ]; then
 +    pass "eval for indirect assignment"
 +else
 +    fail "eval for indirect assignment" "42" "$result"
 +fi
++
 +# =====================================
 +section "423. RETURN FROM FUNCTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "before" ]; then
 +    pass "return without value"
 +else
 +    fail "return without value" "before" "$result"
 +fi
++
 +# =====================================
 +section "424. FUNCTION LOCAL VARIABLES"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    fail "local variable in function" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "set" ]; then
 +    pass "local without initial value"
 +else
 +    fail "local without initial value" "set" "$result"
 +fi
++
 +# =====================================
 +section "425. FUNCTION RECURSION"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c '
 +factorial() {
 +    if [ $1 -le 1 ]; then
 +        echo 1
 +    else
 +        prev=$(factorial $(($1 - 1)))
 +        echo $(($1 * prev))
 +    fi
 +}
 +factorial 5' 2>&1)
 +if [ "$result" = "120" ]; then
 +    pass "Recursive function (factorial)"
 +else
 +    fail "Recursive function (factorial)" "120" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c '
 +count=0
 +recurse() {
 +    count=$((count + 1))
 +    if [ $count -lt 5 ]; then
 +        recurse
 +    fi
 +    echo $count
 +}
 +recurse | tail -1' 2>&1)
 +if [ "$result" = "5" ]; then
 +    pass "Recursive function with global state"
 +else
 +    fail "Recursive function with global state" "5" "$result"
 +fi
++
 +# =====================================
 +section "426. FUNCTION ARGUMENTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +expected=$(printf "x\ndone")
 +if [ "$result" = "$expected" ]; then
 +    pass "set -- in function is local"
 +else
 +    fail "set -- in function is local" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "427. FUNCTION OVERRIDE"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "new" ]; then
 +    pass "Function sees redefined function"
 +else
 +    fail "Function sees redefined function" "new" "$result"
 +fi
++
 +# =====================================
 +section "428. UNSET FUNCTION"
 +# =====================================
++
 +result=$("$FORTSH_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
 +    fail "unset -f removes function" "non-zero exit" "$result"
 +fi
++
 +# =====================================
 +section "429. COLON BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "ok" ]; then
 +    pass ": ignores arguments"
 +else
 +    fail ": ignores arguments" "ok" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c ': ${x:=default}; echo $x' 2>&1)
 +if [ "$result" = "default" ]; then
 +    pass ": for side effects in expansion"
 +else
 +    fail ": for side effects in expansion" "default" "$result"
 +fi
++
 +# =====================================
 +section "426. TRUE AND FALSE BUILTINS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "1" ]; then
 +    pass "false returns 1"
 +else
 +    fail "false returns 1" "1" "$result"
 +fi
++
 +# =====================================
 +section "427. EXIT BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +code=$?
 +if [ $code -eq 42 ]; then
 +    pass "exit with specific code"
 +else
 +    fail "exit with specific code" "42" "$code"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'false; exit' 2>&1)
 +code=$?
 +if [ $code -eq 1 ]; then
 +    pass "exit without arg uses last status"
 +else
 +    fail "exit without arg uses last status" "1" "$code"
 +fi
++
 +# =====================================
 +section "430. CASE STATEMENT PATTERNS"
 +# =====================================
++
 +# Simple exact match
 +result=$("$FORTSH_BIN" -c 'case "hello" in hello) echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case exact match"
 +else
 +    fail "case exact match" "yes" "$result"
 +fi
++
 +# Glob pattern match
 +result=$("$FORTSH_BIN" -c 'case "hello" in h*) echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case glob pattern"
 +else
 +    fail "case glob pattern" "yes" "$result"
 +fi
++
 +# Question mark match
 +result=$("$FORTSH_BIN" -c 'case "cat" in c?t) echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case ? pattern"
 +else
 +    fail "case ? pattern" "yes" "$result"
 +fi
++
 +# Bracket pattern
 +result=$("$FORTSH_BIN" -c 'case "b" in [abc]) echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case [abc] bracket pattern"
 +else
 +    fail "case [abc] bracket pattern" "yes" "$result"
 +fi
++
 +# Multiple patterns with |
 +result=$("$FORTSH_BIN" -c 'case "two" in one|two|three) echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case multiple patterns with |"
 +else
 +    fail "case multiple patterns with |" "yes" "$result"
 +fi
++
 +# Default pattern *
 +result=$("$FORTSH_BIN" -c 'case "xyz" in abc) echo no;; *) echo default;; esac' 2>&1)
 +if [ "$result" = "default" ]; then
 +    pass "case * default pattern"
 +else
 +    fail "case * default pattern" "default" "$result"
 +fi
++
 +# No match produces nothing
 +result=$("$FORTSH_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
 +    fail "case no match produces empty" "done" "$result"
 +fi
++
 +# Variable in word
 +result=$("$FORTSH_BIN" -c 'x=hello; case "$x" in hello) echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case with variable in word"
 +else
 +    fail "case with variable in word" "yes" "$result"
 +fi
++
 +# Variable in pattern
 +result=$("$FORTSH_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
 +    fail "case with variable in pattern" "yes" "$result"
 +fi
++
 +# Quoted pattern (literal)
 +result=$("$FORTSH_BIN" -c 'case "h*" in "h*") echo yes;; esac' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "case quoted pattern is literal"
 +else
 +    fail "case quoted pattern is literal" "yes" "$result"
 +fi
++
 +# =====================================
 +section "431. NESTED CONTROL STRUCTURES"
 +# =====================================
++
 +# 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)
 +if [ "$result" = "found" ]; then
 +    pass "if inside for loop"
 +else
 +    fail "if inside for loop" "found" "$result"
 +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)
 +if [ "$result" = "one" ]; then
 +    pass "case inside while loop"
 +else
 +    fail "case inside while loop" "one" "$result"
 +fi
++
 +# for inside if
 +result=$("$FORTSH_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"
 +else
 +    fail "for inside if" "$expected" "$result"
 +fi
++
 +# Deeply nested
 +result=$("$FORTSH_BIN" -c '
 +for i in 1; do
 +    for j in 2; do
 +        for k in 3; do
 +            echo "$i$j$k"
 +        done
 +    done
 +done' 2>&1)
 +if [ "$result" = "123" ]; then
 +    pass "Triple nested for loops"
 +else
 +    fail "Triple nested for loops" "123" "$result"
 +fi
++
 +# =====================================
 +section "432. WHILE AND UNTIL LOOPS"
 +# =====================================
++
 +# while with counter
 +result=$("$FORTSH_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"
 +else
 +    fail "while loop with counter" "$expected" "$result"
 +fi
++
 +# until loop
 +result=$("$FORTSH_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"
 +else
 +    fail "until loop" "$expected" "$result"
 +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)
 +expected=$(printf "0\n1\n2")
 +if [ "$result" = "$expected" ]; then
 +    pass "while with compound condition"
 +else
 +    fail "while with compound condition" "$expected" "$result"
 +fi
++
 +# Empty while body (using :)
 +result=$("$FORTSH_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
 +    fail "while with empty body (colon)" "3" "$result"
 +fi
++
 +# =====================================
 +section "433. BREAK AND CONTINUE"
 +# =====================================
++
 +# break in while
 +result=$("$FORTSH_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
 +    fail "break in while loop" "3" "$result"
 +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)
 +expected=$(printf "1\n2\n4\n5")
 +if [ "$result" = "$expected" ]; then
 +    pass "continue in for loop"
 +else
 +    fail "continue in for loop" "$expected" "$result"
 +fi
++
 +# break N for nested loops
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2; do
 +    for j in a b; do
 +        echo "$i$j"
 +        [ "$j" = "a" ] && break 2
 +    done
 +done
 +echo done' 2>&1)
 +expected=$(printf "1a\ndone")
 +if [ "$result" = "$expected" ]; then
 +    pass "break 2 exits outer loop"
 +else
 +    fail "break 2 exits outer loop" "$expected" "$result"
 +fi
++
 +# continue N for nested loops
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2; do
 +    for j in a b; do
 +        [ "$i$j" = "1a" ] && continue 2
 +        echo "$i$j"
 +    done
 +done' 2>&1)
 +expected=$(printf "2a\n2b")
 +if [ "$result" = "$expected" ]; then
 +    pass "continue 2 continues outer loop"
 +else
 +    fail "continue 2 continues outer loop" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "434. FOR LOOP VARIATIONS"
 +# =====================================
++
 +# for without in (uses positional params)
 +result=$("$FORTSH_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 \$@"
 +else
 +    fail "for without 'in' uses \$@" "$expected" "$result"
 +fi
++
 +# 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)
 +if [ "$result" -eq 2 ] 2>/dev/null; then
 +    pass "for with glob expansion"
 +else
 +    fail "for with glob expansion" "2" "$result"
 +fi
++
 +# for with command substitution
 +result=$("$FORTSH_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"
 +else
 +    fail "for with command substitution" "$expected" "$result"
 +fi
++
 +# for with quoted string (single iteration)
 +result=$("$FORTSH_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
 +    fail "for with quoted string (single iteration)" "[a b c]" "$result"
 +fi
++
 +# =====================================
 +section "435. WHILE LOOP VARIATIONS"
 +# =====================================
++
 +# while with pipeline
 +result=$("$FORTSH_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
 +    fail "while loop with pipeline" "3" "$result"
 +fi
++
 +# while with command substitution condition
 +result=$("$FORTSH_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
 +    fail "while with variable condition" "once" "$result"
 +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)
 +if [ "$result" = "5" ]; then
 +    pass "infinite while with break"
 +else
 +    fail "infinite while with break" "5" "$result"
 +fi
++
 +# =====================================
 +section "436. UNTIL LOOP VARIATIONS"
 +# =====================================
++
 +# until basic
 +result=$("$FORTSH_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"
 +else
 +    fail "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)
 +if [ "$result" = "3" ]; then
 +    pass "until with break"
 +else
 +    fail "until with break" "3" "$result"
 +fi
++
 +# =====================================
 +section "437. IF STATEMENT VARIATIONS"
 +# =====================================
++
 +# if with command
 +result=$("$FORTSH_BIN" -c 'if true; then echo yes; fi' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "if with true command"
 +else
 +    fail "if with true command" "yes" "$result"
 +fi
++
 +# if with test
 +result=$("$FORTSH_BIN" -c 'X=5; if [ $X -gt 3 ]; then echo big; fi' 2>&1)
 +if [ "$result" = "big" ]; then
 +    pass "if with test condition"
 +else
 +    fail "if with test condition" "big" "$result"
 +fi
++
 +# if-else
 +result=$("$FORTSH_BIN" -c 'if false; then echo no; else echo yes; fi' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "if-else statement"
 +else
 +    fail "if-else statement" "yes" "$result"
 +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)
 +if [ "$result" = "two" ]; then
 +    pass "if-elif-else statement"
 +else
 +    fail "if-elif-else statement" "two" "$result"
 +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)
 +if [ "$result" = "both" ]; then
 +    pass "nested if statement"
 +else
 +    fail "nested if statement" "both" "$result"
 +fi
++
 +# =====================================
 +section "438. CASE STATEMENT VARIATIONS"
 +# =====================================
++
 +# case with character class
 +result=$("$FORTSH_BIN" -c 'x=5; case $x in [0-9]) echo digit;; esac' 2>&1)
 +if [ "$result" = "digit" ]; then
 +    pass "case with character class"
 +else
 +    fail "case with character class" "digit" "$result"
 +fi
++
 +# case with negation
 +result=$("$FORTSH_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
 +    fail "case with negation" "not_digit" "$result"
 +fi
++
 +# case with question mark
 +result=$("$FORTSH_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
 +    fail "case with question mark pattern" "two_chars" "$result"
 +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)
 +if [ "$result" = "first" ]; then
 +    pass "case first match wins"
 +else
 +    fail "case first match wins" "first" "$result"
 +fi
++
 +# =====================================
 +section "439. BRACE GROUP VARIATIONS"
 +# =====================================
++
 +# brace group in pipeline
 +result=$("$FORTSH_BIN" -c '{ echo a; echo b; } | wc -l' 2>&1)
 +if [ "$result" -eq 2 ] 2>/dev/null; then
 +    pass "brace group in pipeline"
 +else
 +    fail "brace group in pipeline" "2" "$result"
 +fi
++
 +# brace group with redirection
 +result=$("$FORTSH_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
 +    fail "brace group with redirection" "test" "$result"
 +fi
++
 +# brace group preserves variables
 +result=$("$FORTSH_BIN" -c 'X=1; { X=2; }; echo $X' 2>&1)
 +if [ "$result" = "2" ]; then
 +    pass "brace group preserves variable changes"
 +else
 +    fail "brace group preserves variable changes" "2" "$result"
 +fi
++
 +# =====================================
 +section "440. SUBSHELL VARIATIONS"
 +# =====================================
++
 +# subshell in pipeline
 +result=$("$FORTSH_BIN" -c '(echo a; echo b) | wc -l' 2>&1)
 +if [ "$result" -eq 2 ] 2>/dev/null; then
 +    pass "subshell in pipeline"
 +else
 +    fail "subshell in pipeline" "2" "$result"
 +fi
++
 +# subshell isolates variables
 +result=$("$FORTSH_BIN" -c 'X=1; (X=2); echo $X' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "subshell isolates variable changes"
 +else
 +    fail "subshell isolates variable changes" "1" "$result"
 +fi
++
 +# 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
 +fortsh_exit=$?
 +"$BASH_REF" -c '((echo deep))' >/dev/null 2>&1
 +bash_exit=$?
 +if [ "$fortsh_exit" -eq "$bash_exit" ]; then
 +    pass "double paren arithmetic exit"
 +else
 +    fail "double paren arithmetic exit" "exit=$bash_exit" "exit=$fortsh_exit"
 +fi
++
 +# =====================================
 +section "441. COMPOUND LIST VARIATIONS"
 +# =====================================
++
 +# semicolon separated
 +result=$("$FORTSH_BIN" -c 'echo a; echo b; echo c' 2>&1)
 +expected=$(printf "a\nb\nc")
 +if [ "$result" = "$expected" ]; then
 +    pass "semicolon separated commands"
 +else
 +    fail "semicolon separated commands"
 +fi
++
 +# newline separated
 +result=$("$FORTSH_BIN" -c 'echo a
 +echo b
 +echo c' 2>&1)
 +expected=$(printf "a\nb\nc")
 +if [ "$result" = "$expected" ]; then
 +    pass "newline separated commands"
 +else
 +    fail "newline separated commands"
 +fi
++
 +# =====================================
 +section "442. LOGICAL OPERATORS VARIATIONS"
 +# =====================================
++
 +# && chain
 +result=$("$FORTSH_BIN" -c 'true && true && echo success' 2>&1)
 +if [ "$result" = "success" ]; then
 +    pass "&& chain all true"
 +else
 +    fail "&& chain all true" "success" "$result"
 +fi
++
 +# && short-circuit
 +result=$("$FORTSH_BIN" -c 'false && echo never' 2>&1)
 +if [ -z "$result" ]; then
 +    pass "&& short-circuits on false"
 +else
 +    fail "&& short-circuits on false" "empty" "$result"
 +fi
++
 +# || chain
 +result=$("$FORTSH_BIN" -c 'false || false || echo fallback' 2>&1)
 +if [ "$result" = "fallback" ]; then
 +    pass "|| chain with fallback"
 +else
 +    fail "|| chain with fallback" "fallback" "$result"
 +fi
++
 +# || short-circuit
 +result=$("$FORTSH_BIN" -c 'true || echo never' 2>&1)
 +if [ -z "$result" ]; then
 +    pass "|| short-circuits on true"
 +else
 +    fail "|| short-circuits on true" "empty" "$result"
 +fi
++
 +# mixed && and ||
 +result=$("$FORTSH_BIN" -c 'false && echo no || echo yes' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "mixed && and ||"
 +else
 +    fail "mixed && and ||" "yes" "$result"
 +fi
++
 +# =====================================
 +section "443. NEGATION WITH !"
 +# =====================================
++
 +# ! negates exit status
 +result=$("$FORTSH_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)
 +if [ "$result" = "failed" ]; then
 +    pass "! negates true to false"
 +else
 +    fail "! negates true to false" "failed" "$result"
 +fi
++
 +# ! with pipeline
 +result=$("$FORTSH_BIN" -c '! echo test | grep -q nomatch && echo ok' 2>&1)
 +if [ "$result" = "ok" ]; then
 +    pass "! with pipeline"
 +else
 +    fail "! with pipeline" "ok" "$result"
 +fi
++
 +# =====================================
 +section "444. FUNCTION DEFINITIONS"
 +# =====================================
++
 +# function with return
 +result=$("$FORTSH_BIN" -c 'f() { return 42; }; f; echo $?' 2>&1)
 +if [ "$result" = "42" ]; then
 +    pass "function with return value"
 +else
 +    fail "function with return value" "42" "$result"
 +fi
++
 +# function with arguments
 +result=$("$FORTSH_BIN" -c 'greet() { echo "Hello, $1"; }; greet World' 2>&1)
 +if [ "$result" = "Hello, World" ]; then
 +    pass "function with arguments"
 +else
 +    fail "function with arguments" "Hello, World" "$result"
 +fi
++
 +# function calling function
 +result=$("$FORTSH_BIN" -c 'a() { b; }; b() { echo called; }; a' 2>&1)
 +if [ "$result" = "called" ]; then
 +    pass "function calling function"
 +else
 +    fail "function calling function" "called" "$result"
 +fi
++
 +# =====================================
 +section "445. EXIT AND RETURN"
 +# =====================================
++
 +# exit from subshell
 +result=$("$FORTSH_BIN" -c '(exit 7); echo $?' 2>&1)
 +if [ "$result" = "7" ]; then
 +    pass "exit from subshell"
 +else
 +    fail "exit from subshell" "7" "$result"
 +fi
++
 +# return from function
 +result=$("$FORTSH_BIN" -c 'f() { echo before; return; echo after; }; f' 2>&1)
 +if [ "$result" = "before" ]; then
 +    pass "return stops function execution"
 +else
 +    fail "return stops function execution" "before" "$result"
 +fi
++
 +# return default value
 +result=$("$FORTSH_BIN" -c 'f() { true; return; }; f; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass "return with no value uses last exit status"
 +else
 +    fail "return with no value uses last exit status" "0" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Control Flow and Grouping Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_coverage.shadded

 +#!/usr/bin/env bash
 +# 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}"
 +BASH_REF="${BASH_REF:-bash}"
++
 +# Colors
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-coverage]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "200. ARITHMETIC EDGE CASES"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Normalize output by stripping shell name prefix
 +normalize_output() {
 +    sed -e 's|^[^ ]*bash: |sh: |' -e 's|^[^ ]*fortsh: |sh: |' -e 's/line [0-9]*: //'
 +}
++
 +# Compare output between sh and fortsh
 +compare_posix_output() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    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_exit=$?
++
 +    if [ "$posix_output" = "$fortsh_output" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$posix_output" "$fortsh_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'
 +}
++
 +# Compare error output, normalizing line number differences
 +compare_posix_error() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    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_exit=$?
++
 +    posix_norm=$(normalize_error "$posix_output")
 +    fortsh_norm=$(normalize_error "$fortsh_output")
++
 +    if [ "$posix_norm" = "$fortsh_norm" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$posix_output" "$fortsh_output"
 +    fi
 +}
++
 +# Test that fortsh accepts without error
 +test_accepts() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    if FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "should succeed" "failed or not implemented"
 +    fi
 +}
++
 +# Test that command fails
 +test_fails() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    if ! FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "should fail" "succeeded unexpectedly"
 +    fi
 +}
++
 +# =====================================
 +# ARITHMETIC EDGE CASES
 +# =====================================
++
 +section "200. ARITHMETIC - OCTAL AND HEX LITERALS"
++
 +compare_posix_output "octal literal" 'echo $((010))'
 +compare_posix_output "hex literal lowercase" 'echo $((0xff))'
 +compare_posix_output "hex literal uppercase" 'echo $((0xFF))'
 +compare_posix_output "octal in expression" 'echo $((010 + 1))'
 +compare_posix_output "hex in expression" 'echo $((0x10 + 1))'
 +compare_posix_output "mixed bases" 'echo $((0x10 + 010 + 10))'
++
 +section "201. ARITHMETIC - NEGATIVE NUMBERS"
++
 +compare_posix_output "negative literal" 'echo $((-5))'
 +compare_posix_output "negative in addition" 'echo $((10 + -3))'
 +compare_posix_output "negative in subtraction" 'echo $((5 - -3))'
 +compare_posix_output "double negative" 'echo $((--5))'
 +compare_posix_output "negative multiplication" 'echo $((-3 * -4))'
 +compare_posix_output "negative division" 'echo $((-10 / 3))'
 +compare_posix_output "negative modulo" 'echo $((-10 % 3))'
++
 +section "202. ARITHMETIC - NESTED EXPRESSIONS"
++
 +compare_posix_output "nested arithmetic" 'echo $((1 + $((2 + 3))))'
 +compare_posix_output "deeply nested" 'echo $((1 + $((2 + $((3 + 4))))))'
 +compare_posix_output "nested with vars" 'a=5; echo $((a + $((a * 2))))'
++
 +section "203. ARITHMETIC - COMMA OPERATOR"
++
 +compare_posix_output "comma operator" 'echo $((1, 2, 3))'
 +compare_posix_output "comma with assignment" 'echo $((a=1, b=2, a+b))'
 +compare_posix_output "comma side effects" 'a=0; echo $((a=1, a=a+1, a))'
++
 +# =====================================
 +# WORD SPLITTING EDGE CASES
 +# =====================================
++
 +section "210. WORD SPLITTING - EMPTY IFS"
++
 +compare_posix_output "empty IFS no split" 'IFS=""; var="a b c"; set -- $var; echo $#'
 +compare_posix_output "empty IFS preserves spaces" 'IFS=""; var="a  b"; set -- $var; echo "$1"'
++
 +section "211. WORD SPLITTING - IFS VARIATIONS"
++
 +compare_posix_output "IFS whitespace only" 'IFS=" "; var="a  b"; set -- $var; echo $#'
 +compare_posix_output "IFS non-whitespace" 'IFS=":"; var="a:b:c"; set -- $var; echo $#'
 +compare_posix_output "IFS mixed" 'IFS=" :"; var="a : b"; set -- $var; echo $#'
 +compare_posix_output "IFS tab" 'IFS="	"; var="a	b	c"; set -- $var; echo $#'
++
 +section "212. WORD SPLITTING - $@ VS $*"
++
 +compare_posix_output "$* unquoted" 'set -- "a b" "c d"; for x in $*; do echo "[$x]"; done'
 +compare_posix_output "$@ unquoted" 'set -- "a b" "c d"; for x in $@; do echo "[$x]"; done'
 +compare_posix_output "$* quoted" 'set -- "a b" "c d"; for x in "$*"; do echo "[$x]"; done'
 +compare_posix_output "$@ quoted" 'set -- "a b" "c d"; for x in "$@"; do echo "[$x]"; done'
 +compare_posix_output "$* with IFS" 'IFS=:; set -- a b c; echo "$*"'
 +compare_posix_output "$@ with IFS" 'IFS=:; set -- a b c; echo "$@"'
++
 +# =====================================
 +# PARAMETER EXPANSION EDGE CASES
 +# =====================================
++
 +section "220. PARAMETER EXPANSION - EMPTY VS UNSET"
++
 +compare_posix_output ":+ empty var" 'var=""; echo "${var:+set}"'
 +compare_posix_output ":+ unset var" 'unset var; echo "${var:+set}"'
 +compare_posix_output "+ empty var" 'var=""; echo "${var+set}"'
 +compare_posix_output "+ unset var" 'unset var; echo "${var+set}"'
 +compare_posix_output ":- empty var" 'var=""; echo "${var:-default}"'
 +compare_posix_output "- empty var" 'var=""; echo "${var-default}"'
++
 +section "221. PARAMETER EXPANSION - ASSIGNMENT FORMS"
++
 +compare_posix_output ":= assigns when empty" 'unset var; echo "${var:=default}"; echo "$var"'
 +compare_posix_output "= assigns when unset" 'unset var; echo "${var=default}"; echo "$var"'
 +compare_posix_output ":= with empty" 'var=""; echo "${var:=default}"; echo "$var"'
 +compare_posix_output "= with empty" 'var=""; echo "${var=default}"; echo "$var"'
++
 +section "222. PARAMETER EXPANSION - PATTERN IN EXPANSION"
++
 +compare_posix_output "nested pattern removal" 'suffix=.txt; file=test.txt; echo "${file%$suffix}"'
 +compare_posix_output "var in pattern" 'pat=t; var=test; echo "${var#$pat}"'
 +compare_posix_output "var in suffix pattern" 'pat=st; var=test; echo "${var%$pat}"'
++
 +# =====================================
 +# SIGNAL AND TRAP EDGE CASES
 +# =====================================
++
 +section "230. TRAP - IGNORE VS RESET"
++
 +# Test trap behavior by checking patterns (bash versions may differ in exact output format)
 +test_trap_behavior() {
 +    test_name="$1"
 +    test_cmd="$2"
 +    expected_pattern="$3"
++
 +    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
++
 +    if echo "$output" | grep -qE "$expected_pattern"; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "expected pattern: $expected_pattern" "got: $output"
 +    fi
 +}
++
 +# trap "" INT sets ignore, trap shows it, trap - INT resets, trap shows nothing for INT
 +test_trap_behavior "trap ignore" 'trap "" INT; trap; trap - INT; trap' "trap.*INT"
 +test_trap_behavior "trap reset" 'trap "echo caught" INT; trap - INT; trap' "^$"
 +compare_posix_output "trap empty string" 'trap "" EXIT; echo done'
++
 +section "231. TRAP - IN SUBSHELLS"
++
 +# Non-ignored traps should show in parent but subshell inherits parent's trap display
 +# The EXIT trap runs when done, printing "trap"
 +test_trap_behavior "trap not inherited" 'trap "echo trap" EXIT; (trap); echo done' "done"
 +# Ignored traps ARE inherited by subshells
 +test_trap_behavior "ignore trap inherited" 'trap "" INT; (trap)' "trap.*INT"
++
 +section "232. TRAP - MULTIPLE SIGNALS"
++
 +compare_posix_output "trap multiple" 'trap "echo exit" EXIT; trap "echo err" ERR 2>/dev/null || true; echo done'
++
 +# =====================================
 +# ERROR HANDLING EDGE CASES
 +# =====================================
++
 +section "240. SET -e EDGE CASES"
++
 +compare_posix_output "set -e with &&" 'set -e; false && true; echo reached'
 +compare_posix_output "set -e with ||" 'set -e; false || true; echo reached'
 +compare_posix_output "set -e with !" 'set -e; ! false; echo reached'
 +compare_posix_output "set -e in if condition" 'set -e; if false; then echo no; fi; echo reached'
 +compare_posix_output "set -e in while condition" 'set -e; while false; do echo no; done; echo reached'
++
 +section "241. SET -e IN SUBSHELLS"
++
 +compare_posix_output "set -e inherited" 'set -e; (false; echo no) || echo caught'
 +compare_posix_output "set -e in command sub" 'set -e; x=$(false; echo yes); echo "x=$x"'
++
 +section "242. COMMAND NOT FOUND"
++
 +# Test exit status for command not found (should be 127)
 +test_cmd='nonexistent_command_12345 2>/dev/null; echo $?'
 +compare_posix_output "command not found status" "$test_cmd"
++
 +# =====================================
 +# FUNCTION EDGE CASES
 +# =====================================
++
 +section "250. FUNCTION - BUILTIN SHADOWING"
++
 +compare_posix_output "function shadows builtin" 'echo() { printf "custom: %s\n" "$1"; }; echo test; unset -f echo'
 +compare_posix_output "function named cd" 'cd() { echo "custom cd"; }; cd /tmp; unset -f cd'
++
 +section "251. FUNCTION - REDEFINITION"
++
 +compare_posix_output "redefine function" 'f() { echo v1; }; f; f() { echo v2; }; f'
++
 +section "252. FUNCTION - INDIRECT RECURSION"
++
 +compare_posix_output "mutual recursion" 'a() { [ $1 -le 0 ] && echo done || b $(($1-1)); }; b() { a $1; }; a 3'
++
 +section "253. FUNCTION - RETURN EDGE CASES"
++
 +compare_posix_output "return outside function" '(return 5 2>/dev/null); echo $?'
 +compare_posix_output "return in sourced file" 'echo "return 42" > /tmp/ret.sh; . /tmp/ret.sh; echo $?; rm /tmp/ret.sh'
++
 +# =====================================
 +# REDIRECTION EDGE CASES
 +# =====================================
++
 +section "260. REDIRECTION - CLOSED FD OPERATIONS"
++
 +compare_posix_error "write to closed fd" 'exec 3>&-; echo test >&3 2>&1 | head -1'
 +compare_posix_error "read from closed fd" 'exec 3<&-; cat <&3 2>&1 | head -1'
++
 +section "261. REDIRECTION - MULTIPLE HEREDOCS"
++
 +compare_posix_output "two heredocs" 'cat <<EOF1; cat <<EOF2
 +first
 +EOF1
 +second
 +EOF2'
++
 +section "262. REDIRECTION - NOCLOBBER WITH APPEND"
++
 +compare_posix_output "noclobber allows append" 'set -C; echo a > /tmp/nc_test; echo b >> /tmp/nc_test; cat /tmp/nc_test; rm /tmp/nc_test'
++
 +# =====================================
 +# PIPELINE EDGE CASES
 +# =====================================
++
 +section "270. PIPELINE - BUILTIN ONLY"
++
 +compare_posix_output "pipeline all builtins" 'echo test | { read x; echo "got: $x"; }'
 +compare_posix_output "pipeline with :" ': | echo piped'
++
 +section "271. PIPELINE - LONG CHAINS"
++
 +compare_posix_output "5-stage pipeline" 'echo test | cat | cat | cat | cat | cat'
 +# 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)
 +if [ "$_pf_expected" = "$_pf_actual" ]; then pass "pipeline with failures"
 +else fail "pipeline with failures" "$_pf_expected" "$_pf_actual"; fi
++
 +# =====================================
 +# ALIAS EDGE CASES
 +# =====================================
++
 +section "280. ALIAS - SPECIAL CASES"
++
 +compare_posix_error "alias with quotes" "alias greet='echo hello'; greet; unalias greet"
 +compare_posix_error "alias with semicolon" "alias both='echo a; echo b'; both; unalias both"
 +compare_posix_output "alias -p format" 'alias foo=bar; alias -p | grep foo; unalias foo'
++
 +section "281. ALIAS - EXPANSION CONTEXT"
++
 +# Aliases don't expand in non-interactive mode - both bash and fortsh should fail
 +# Test that we get "command not found" error (exact format varies by bash version)
 +test_alias_behavior() {
 +    test_name="$1"
 +    test_cmd="$2"
 +    expected_pattern="$3"
++
 +    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
++
 +    if echo "$output" | grep -qiE "$expected_pattern"; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "expected pattern: $expected_pattern" "got: $output"
 +    fi
 +}
++
 +test_alias_behavior "alias in function" "alias e=echo; f() { e test; }; f; unalias e" "command not found|not found"
++
 +# =====================================
 +# DOT (SOURCE) EDGE CASES
 +# =====================================
++
 +section "290. DOT - PATH HANDLING"
++
 +compare_posix_output "dot with arguments" 'echo "echo args: \$1 \$2" > /tmp/src.sh; . /tmp/src.sh a b; rm /tmp/src.sh'
 +compare_posix_output "dot return value" 'echo "false" > /tmp/src.sh; . /tmp/src.sh; echo $?; rm /tmp/src.sh'
 +compare_posix_output "dot modifies vars" 'echo "X=modified" > /tmp/src.sh; X=original; . /tmp/src.sh; echo $X; rm /tmp/src.sh'
++
 +# =====================================
 +# SPECIAL BUILTIN EDGE CASES
 +# =====================================
++
 +section "300. SPECIAL BUILTINS - ERROR BEHAVIOR"
++
 +compare_posix_output "break outside loop" '(break 2>/dev/null); echo $?'
 +compare_posix_output "continue outside loop" '(continue 2>/dev/null); echo $?'
 +compare_posix_output "colon with redirect" ': > /tmp/colon_test; test -f /tmp/colon_test && echo exists; rm /tmp/colon_test'
++
 +# =====================================
 +# ENVIRONMENT EDGE CASES
 +# =====================================
++
 +section "310. ENVIRONMENT - PATH HANDLING"
++
 +compare_posix_output "empty PATH component" 'echo "echo found" > /tmp/pathtest; chmod +x /tmp/pathtest; PATH="/tmp:$PATH" pathtest; rm /tmp/pathtest'
++
 +section "311. ENVIRONMENT - EXPORT BEHAVIOR"
++
 +compare_posix_output "export in subshell" 'X=1; (export X=2); echo $X'
 +compare_posix_output "export preserves" 'export X=1; X=2; sh -c "echo \$X"'
++
 +# =====================================
 +# GLOB EDGE CASES
 +# =====================================
++
 +section "320. GLOB - SPECIAL FILENAMES"
++
 +compare_posix_output "glob with spaces" 'mkdir -p /tmp/gt; touch "/tmp/gt/a b"; echo /tmp/gt/*; rm -r /tmp/gt'
 +compare_posix_output "glob no match" 'echo /nonexistent/path/*.xyz 2>/dev/null'
++
 +section "321. GLOB - CHARACTER CLASSES"
++
 +compare_posix_output "glob [:alpha:]" 'mkdir -p /tmp/gc; touch /tmp/gc/a1 /tmp/gc/1a; echo /tmp/gc/[[:alpha:]]*; rm -r /tmp/gc'
 +compare_posix_output "glob [:digit:]" 'mkdir -p /tmp/gc; touch /tmp/gc/a1 /tmp/gc/1a; echo /tmp/gc/[[:digit:]]*; rm -r /tmp/gc'
++
 +# =====================================
 +# QUOTING EDGE CASES
 +# =====================================
++
 +section "330. QUOTING - COMPLEX NESTING"
++
 +compare_posix_output "quotes in command sub" 'echo "$(echo "inner")"'
 +compare_posix_output "escaped quotes" 'echo "say \"hello\""'
 +compare_posix_output "single in double" "echo \"it's\""
 +compare_posix_output "backslash in single" "echo 'back\\slash'"
++
 +section "331. QUOTING - EMPTY STRINGS"
++
 +compare_posix_output "empty preserves arg" 'set -- "" "a"; echo $#'
 +compare_posix_output "unquoted empty gone" 'e=""; set -- $e a; echo $#'
++
 +# =====================================
 +# MISCELLANEOUS EDGE CASES
 +# =====================================
++
 +section "340. MISC - COMPOUND COMMANDS"
++
 +compare_posix_output "if with compound cond" 'if true && true; then echo yes; fi'
 +compare_posix_output "while with pipeline cond" 'n=0; while echo $n | grep -q 0 && [ $n -lt 1 ]; do n=$((n+1)); done; echo $n'
++
 +section "341. MISC - COMPLEX COMBINATIONS"
++
 +compare_posix_output "redirect in loop" 'for i in 1 2 3; do echo $i; done > /tmp/loop_out; cat /tmp/loop_out; rm /tmp/loop_out'
 +compare_posix_output "case with patterns" 'x=abc; case $x in a*) echo match;; esac'
++
 +# =====================================
 +# SUMMARY
 +# =====================================
++
 +printf "\n==========================================\n"
 +printf "COVERAGE GAP TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +if [ "$((PASSED + FAILED))" -gt 0 ]; then
 +    pass_rate=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%%\n" "$pass_rate"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL COVERAGE GAP TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_compliance_extended.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Extended Test Suite for fortsh
 +# =====================================
 +# Comprehensive POSIX compliance testing based on IEEE Std 1003.1-2017
 +# This extends the basic test suite with additional coverage
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-extended]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "26. EXTENDED TEST"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Helper function to run command in both shells and compare
 +compare_posix_output() {
 +    test_name="$1"
 +    command="$2"
 +    posix_file="/tmp/posix_ext_$$_posix"
 +    fortsh_file="/tmp/posix_ext_$$_fortsh"
++
 +    # Run in POSIX shell (sh)
 +    "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
++
 +    # Run in fortsh
 +    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
++
 +    # Compare outputs
 +    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +    fi
++
 +    rm -f "$posix_file" "$fortsh_file"
 +}
++
 +# Helper function to compare exit codes
 +compare_posix_exit_code() {
 +    test_name="$1"
 +    command="$2"
++
 +    "$BASH_REF" -c "$command" > /dev/null 2>&1
 +    posix_exit=$?
++
 +    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    fortsh_exit=$?
++
 +    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +    fi
 +}
++
 +# Cleanup
 +cleanup() {
 +    rm -f /tmp/posix_ext_$$_* 2>/dev/null
 +    rm -f /tmp/posix_test_* 2>/dev/null
 +    rm -rf /tmp/posix_test_dir 2>/dev/null
 +}
 +trap cleanup EXIT INT TERM
++
 +# Setup test environment
 +mkdir -p /tmp/posix_test_dir
 +cd /tmp/posix_test_dir || exit 1
++
 +section "26. EXTENDED TEST COMMAND - FILE TYPE TESTS"
++
 +# Create test files with different properties
 +touch /tmp/posix_test_regular
 +chmod 644 /tmp/posix_test_regular
 +echo "data" > /tmp/posix_test_nonempty
 +mkdir -p /tmp/posix_test_directory
 +mkfifo /tmp/posix_test_fifo 2>/dev/null || skip "mkfifo" "not available"
 +ln -sf /tmp/posix_test_regular /tmp/posix_test_symlink 2>/dev/null
++
 +compare_posix_exit_code "test -e exists" "test -e /tmp/posix_test_regular"
 +compare_posix_exit_code "test -e nonexistent" "! test -e /tmp/nonexistent_xyz_$$"
 +compare_posix_exit_code "test -f regular file" "test -f /tmp/posix_test_regular"
 +compare_posix_exit_code "test -d directory" "test -d /tmp/posix_test_directory"
 +compare_posix_exit_code "test -s non-empty" "test -s /tmp/posix_test_nonempty"
 +compare_posix_exit_code "test -s empty" "! test -s /tmp/posix_test_regular"
++
 +# Symlink tests (if supported)
 +if [ -L /tmp/posix_test_symlink ]; then
 +    compare_posix_exit_code "test -L symlink" "test -L /tmp/posix_test_symlink"
 +    compare_posix_exit_code "test -h symlink" "test -h /tmp/posix_test_symlink"
 +fi
++
 +# FIFO tests (if created successfully)
 +if [ -p /tmp/posix_test_fifo ]; then
 +    compare_posix_exit_code "test -p fifo" "test -p /tmp/posix_test_fifo"
 +fi
++
 +section "27. EXTENDED TEST COMMAND - FILE PERMISSION TESTS"
++
 +# Create files with specific permissions
 +touch /tmp/posix_test_readable
 +chmod 644 /tmp/posix_test_readable
 +touch /tmp/posix_test_writable
 +chmod 644 /tmp/posix_test_writable
 +touch /tmp/posix_test_executable
 +chmod 755 /tmp/posix_test_executable
++
 +compare_posix_exit_code "test -r readable" "test -r /tmp/posix_test_readable"
 +compare_posix_exit_code "test -w writable" "test -w /tmp/posix_test_writable"
 +compare_posix_exit_code "test -x executable" "test -x /tmp/posix_test_executable"
 +compare_posix_exit_code "test ! -x nonexec" "! test -x /tmp/posix_test_readable"
++
 +section "28. EXTENDED TEST COMMAND - FILE COMPARISON"
++
 +# Create files for comparison
 +echo "old" > /tmp/posix_test_old
 +sleep 1
 +echo "new" > /tmp/posix_test_new
 +ln -f /tmp/posix_test_old /tmp/posix_test_hardlink 2>/dev/null
++
 +compare_posix_exit_code "test -nt newer than" "test /tmp/posix_test_new -nt /tmp/posix_test_old"
 +compare_posix_exit_code "test -ot older than" "test /tmp/posix_test_old -ot /tmp/posix_test_new"
++
 +# Hard link test (if supported)
 +if [ -f /tmp/posix_test_hardlink ]; then
 +    compare_posix_exit_code "test -ef same file" "test /tmp/posix_test_old -ef /tmp/posix_test_hardlink"
 +fi
++
 +section "29. EXTENDED TEST COMMAND - STRING TESTS"
++
 +compare_posix_exit_code "test -n nonempty string" "test -n 'hello'"
 +compare_posix_exit_code "test -z empty string" "test -z ''"
 +compare_posix_exit_code "test string = equal" "test 'abc' = 'abc'"
 +compare_posix_exit_code "test string != not equal" "test 'abc' != 'xyz'"
 +compare_posix_exit_code "test unary string" "test 'hello'"
 +compare_posix_exit_code "test ! negation" "! test -z 'hello'"
++
 +section "30. EXTENDED TEST COMMAND - INTEGER COMPARISON"
++
 +compare_posix_exit_code "test -eq equal" "test 42 -eq 42"
 +compare_posix_exit_code "test -ne not equal" "test 42 -ne 13"
 +compare_posix_exit_code "test -gt greater" "test 10 -gt 5"
 +compare_posix_exit_code "test -ge greater or equal" "test 10 -ge 10"
 +compare_posix_exit_code "test -lt less" "test 5 -lt 10"
 +compare_posix_exit_code "test -le less or equal" "test 5 -le 5"
 +compare_posix_exit_code "test negative numbers" "test -5 -lt 0"
++
 +section "31. EXTENDED TEST COMMAND - LOGICAL OPERATORS"
++
 +compare_posix_exit_code "test -a and" "test 5 -gt 3 -a 10 -gt 8"
 +compare_posix_exit_code "test -o or" "test 5 -gt 10 -o 10 -gt 8"
 +compare_posix_exit_code "test ! negation" "! test 5 -gt 10"
 +compare_posix_exit_code "test ( ) grouping" "test \( 5 -gt 3 \) -a \( 10 -gt 8 \)"
++
 +section "32. EXTENDED PARAMETER EXPANSION - DEFAULT VALUES"
++
 +compare_posix_output "use default unset" 'unset VAR; echo "${VAR-default}"'
 +compare_posix_output "use default null" 'VAR=; echo "${VAR-default}"'
 +compare_posix_output "use default null colon" 'VAR=; echo "${VAR:-default}"'
 +compare_posix_output "use default set" 'VAR=value; echo "${VAR-default}"'
 +compare_posix_output "assign default unset" 'unset VAR; echo "${VAR=assigned}"; echo $VAR'
 +compare_posix_output "assign default null colon" 'VAR=; echo "${VAR:=assigned}"; echo $VAR'
++
 +section "33. EXTENDED PARAMETER EXPANSION - ERROR IF UNSET"
++
 +compare_posix_exit_code "error if unset" 'unset VAR; echo "${VAR?error}" 2>/dev/null'
 +compare_posix_exit_code "error if null colon" 'VAR=; echo "${VAR:?error}" 2>/dev/null'
 +compare_posix_output "no error if set" 'VAR=value; echo "${VAR?error}"'
++
 +section "34. EXTENDED PARAMETER EXPANSION - ALTERNATIVE VALUE"
++
 +compare_posix_output "alt unset" 'unset VAR; echo "${VAR+alternative}"'
 +compare_posix_output "alt null" 'VAR=; echo "${VAR+alternative}"'
 +compare_posix_output "alt null colon" 'VAR=; echo "${VAR:+alternative}"'
 +compare_posix_output "alt set" 'VAR=value; echo "${VAR+alternative}"'
 +compare_posix_output "alt set colon" 'VAR=value; echo "${VAR:+alternative}"'
++
 +section "35. EXTENDED PARAMETER EXPANSION - STRING LENGTH"
++
 +compare_posix_output "length empty" 'VAR=; echo "${#VAR}"'
 +compare_posix_output "length short" 'VAR=hi; echo "${#VAR}"'
 +compare_posix_output "length long" 'VAR="hello world"; echo "${#VAR}"'
 +compare_posix_output "length special chars" 'VAR="a b c"; echo "${#VAR}"'
++
 +section "36. EXTENDED PARAMETER EXPANSION - PATTERN REMOVAL"
++
 +# Prefix removal
 +compare_posix_output "prefix # simple" 'VAR=hello; echo "${VAR#hel}"'
 +compare_posix_output "prefix # nomatch" 'VAR=hello; echo "${VAR#xyz}"'
 +compare_posix_output "prefix # glob" 'VAR=foo.bar.baz; echo "${VAR#*.}"'
 +compare_posix_output "prefix ## glob" 'VAR=foo.bar.baz; echo "${VAR##*.}"'
 +compare_posix_output "prefix # star" 'VAR=/usr/local/bin; echo "${VAR#*/}"'
 +compare_posix_output "prefix ## star" 'VAR=/usr/local/bin; echo "${VAR##*/}"'
++
 +# Suffix removal
 +compare_posix_output "suffix % simple" 'VAR=hello; echo "${VAR%lo}"'
 +compare_posix_output "suffix % nomatch" 'VAR=hello; echo "${VAR%xyz}"'
 +compare_posix_output "suffix % glob" 'VAR=foo.bar.baz; echo "${VAR%.*}"'
 +compare_posix_output "suffix %% glob" 'VAR=foo.bar.baz; echo "${VAR%%.*}"'
 +compare_posix_output "suffix % extension" 'VAR=file.tar.gz; echo "${VAR%.gz}"'
 +compare_posix_output "suffix %% extension" 'VAR=file.tar.gz; echo "${VAR%%.*}"'
++
 +section "37. ARITHMETIC EXPANSION - BASIC OPERATIONS"
++
 +compare_posix_output "arith addition" 'echo $((5 + 3))'
 +compare_posix_output "arith subtraction" 'echo $((10 - 4))'
 +compare_posix_output "arith multiplication" 'echo $((6 * 7))'
 +compare_posix_output "arith division" 'echo $((20 / 4))'
 +compare_posix_output "arith modulo" 'echo $((17 % 5))'
 +compare_posix_output "arith negative" 'echo $((-5 + 10))'
 +compare_posix_output "arith zero" 'echo $((0 + 0))'
++
 +section "38. ARITHMETIC EXPANSION - PRECEDENCE"
++
 +compare_posix_output "arith precedence mult" 'echo $((2 + 3 * 4))'
 +compare_posix_output "arith precedence paren" 'echo $(((2 + 3) * 4))'
 +compare_posix_output "arith precedence div" 'echo $((10 - 8 / 2))'
 +compare_posix_output "arith precedence complex" 'echo $((2 * 3 + 4 * 5))'
++
 +section "39. ARITHMETIC EXPANSION - VARIABLES"
++
 +compare_posix_output "arith var" 'X=5; echo $((X + 3))'
 +compare_posix_output "arith var no dollar" 'X=10; Y=20; echo $((X + Y))'
 +compare_posix_output "arith var assign" 'X=5; Y=$((X * 2)); echo $Y'
 +compare_posix_output "arith var complex" 'A=3; B=4; echo $((A * A + B * B))'
++
 +section "40. ARITHMETIC EXPANSION - COMPARISON"
++
 +compare_posix_output "arith compare eq true" 'echo $((5 == 5))'
 +compare_posix_output "arith compare eq false" 'echo $((5 == 3))'
 +compare_posix_output "arith compare ne true" 'echo $((5 != 3))'
 +compare_posix_output "arith compare ne false" 'echo $((5 != 5))'
 +compare_posix_output "arith compare lt" 'echo $((3 < 5))'
 +compare_posix_output "arith compare le" 'echo $((5 <= 5))'
 +compare_posix_output "arith compare gt" 'echo $((7 > 5))'
 +compare_posix_output "arith compare ge" 'echo $((5 >= 5))'
++
 +section "41. ARITHMETIC EXPANSION - LOGICAL"
++
 +compare_posix_output "arith logical and true" 'echo $((1 && 1))'
 +compare_posix_output "arith logical and false" 'echo $((1 && 0))'
 +compare_posix_output "arith logical or true" 'echo $((0 || 1))'
 +compare_posix_output "arith logical or false" 'echo $((0 || 0))'
 +compare_posix_output "arith logical not true" 'echo $((! 0))'
 +compare_posix_output "arith logical not false" 'echo $((! 1))'
++
 +section "42. SPECIAL PARAMETERS"
++
 +compare_posix_output "\$\$ process id type" 'echo $$ | grep -c "^[0-9][0-9]*$"'
 +compare_posix_output "\$- shell flags type" 'echo $- | grep -c "^[a-z]*$"'
 +compare_posix_output "\$# arg count" 'set -- a b c; echo $#'
 +compare_posix_output "\$1 first arg" 'set -- first second; echo $1'
 +compare_posix_output "\$2 second arg" 'set -- first second; echo $2'
 +compare_posix_output "\$9 ninth arg" 'set -- a b c d e f g h i j; echo $9'
 +compare_posix_output "\$* all args" 'set -- a b c; echo $*'
 +compare_posix_output "\$@ all args" 'set -- a b c; echo $@'
++
 +section "43. ADDITIONAL POSIX BUILTINS - CD/PWD"
++
 +compare_posix_output "cd to /tmp" 'cd /tmp && pwd'
 +compare_posix_output "cd relative" 'cd /tmp && cd .. && pwd | grep -c "^/"'
 +compare_posix_output "cd $HOME" 'cd && pwd | grep -c "^/"'
++
 +section "44. ADDITIONAL POSIX BUILTINS - UNSET"
++
 +compare_posix_output "unset variable" 'VAR=test; unset VAR; echo ${VAR:-unset}'
 +compare_posix_output "unset nonexistent" 'unset NONEXISTENT_VAR_XYZ; echo ok'
++
 +section "45. ADDITIONAL POSIX BUILTINS - EVAL"
++
 +compare_posix_output "eval simple" 'CMD="echo hello"; eval $CMD'
 +compare_posix_output "eval with var" 'X=5; CMD="echo \$X"; eval $CMD'
 +compare_posix_output "eval complex" 'A=echo; B=test; eval $A $B'
++
 +section "46. ADDITIONAL POSIX BUILTINS - COLON"
++
 +compare_posix_output ": null command" ': ; echo ok'
 +compare_posix_output ": with args" ': this is ignored; echo ok'
 +compare_posix_exit_code ": exit status" ':'
++
 +section "47. TILDE EXPANSION"
++
 +compare_posix_output "tilde home" 'echo ~ | grep -c "^/"'
 +compare_posix_output "tilde in path" 'echo ~/test | grep -c "^/"'
++
 +section "48. FIELD SPLITTING - ADVANCED"
++
 +compare_posix_output "IFS multiple fields" 'IFS=:; VAR="a:b:c:d"; set -- $VAR; echo $# $1 $4'
 +compare_posix_output "IFS whitespace" 'IFS=" "; VAR="a b c"; set -- $VAR; echo $#'
 +compare_posix_output "IFS comma" 'IFS=,; VAR="x,y,z"; set -- $VAR; echo $2'
++
 +section "49. BACKGROUND JOBS"
++
 +compare_posix_exit_code "background process" 'sleep 0.1 & wait'
 +compare_posix_output "background exit" '(exit 0) & wait $!; echo $?'
++
 +section "50. COMMAND GROUPING"
++
 +compare_posix_output "subshell isolation" 'X=1; (X=2; echo $X); echo $X'
 +compare_posix_output "brace grouping" 'X=1; { X=2; echo $X; }; echo $X'
 +compare_posix_output "subshell exit" '(exit 5); echo $?'
++
 +section "51. GLOB PATTERN MATCHING"
++
 +# Create temp dir for glob tests
 +GLOB_DIR="/tmp/posix_glob_test_$$"
 +mkdir -p "$GLOB_DIR"
 +touch "$GLOB_DIR/file1.txt" "$GLOB_DIR/file2.txt" "$GLOB_DIR/file3.log"
 +touch "$GLOB_DIR/abc" "$GLOB_DIR/abd" "$GLOB_DIR/acd"
++
 +compare_posix_output "star matches multiple" 'cd '"$GLOB_DIR"' && echo file*.txt | tr " " "\n" | wc -l'
 +compare_posix_output "question mark single char" 'cd '"$GLOB_DIR"' && echo ab? | tr " " "\n" | wc -l'
 +compare_posix_output "bracket range" 'cd '"$GLOB_DIR"' && echo a[bc]d | tr " " "\n" | wc -l'
 +compare_posix_output "no match literal" 'cd '"$GLOB_DIR"' && echo zzz*.xyz 2>/dev/null || echo "zzz*.xyz"'
++
 +rm -rf "$GLOB_DIR"
++
 +section "52. DOTFILE HANDLING"
++
 +DOT_DIR="/tmp/posix_dot_test_$$"
 +mkdir -p "$DOT_DIR"
 +touch "$DOT_DIR/.hidden" "$DOT_DIR/visible"
++
 +compare_posix_output "star no dotfiles" 'cd '"$DOT_DIR"' && echo * | grep -c hidden || echo 0'
 +compare_posix_output "explicit dot matches" 'cd '"$DOT_DIR"' && ls -d .* 2>/dev/null | grep -c hidden'
++
 +rm -rf "$DOT_DIR"
++
 +section "53. QUOTING IN GLOB"
++
 +QUOTE_DIR="/tmp/posix_quote_glob_$$"
 +mkdir -p "$QUOTE_DIR"
 +touch "$QUOTE_DIR/star"
++
 +compare_posix_output "quoted star literal" 'cd '"$QUOTE_DIR"' && echo "*" | grep -c "\\*"'
 +compare_posix_output "single quote prevents glob" "cd '$QUOTE_DIR' && echo '*' | grep -c '\\*'"
++
 +rm -rf "$QUOTE_DIR"
++
 +section "54. EMPTY AND NULL EXPANSION"
++
 +compare_posix_output "unset var empty" 'unset X; echo "[$X]"'
 +compare_posix_output "null var empty" 'X=""; echo "[$X]"'
 +compare_posix_output "unset in arith" 'unset X; echo $((X + 1))'
++
 +section "55. SPECIAL VARIABLES READONLY"
++
 +compare_posix_output "cannot assign to ?" '(eval "?=5" 2>/dev/null); echo ok'
 +compare_posix_output "cannot assign to $" '(eval "\$=5" 2>/dev/null); echo ok'
++
 +section "56. COMPLEX COMMAND LISTS"
++
 +compare_posix_output "and-or chain" 'true && echo yes || echo no'
 +compare_posix_output "or-and chain" 'false || echo fallback && echo then'
 +compare_posix_output "semicolon list" 'echo a; echo b; echo c'
 +compare_posix_output "mixed operators" 'true && true && echo all || echo none'
++
 +section "57. NESTED SUBSHELLS"
++
 +compare_posix_output "double nesting" '( ( echo deep ) )'
 +compare_posix_output "triple nesting" '( ( ( echo deeper ) ) )'
 +compare_posix_output "nested with vars" 'X=1; ( X=2; ( X=3; echo $X ) ); echo $X'
++
 +section "58. BRACE GROUP EDGE CASES"
++
 +compare_posix_output "brace needs space" '{ echo test; }'
 +compare_posix_output "brace with semicolon" '{ echo a; echo b; }'
 +compare_posix_output "brace preserves vars" 'X=1; { X=2; }; echo $X'
++
 +section "59. ARITHMETIC BASE LITERALS"
++
 +compare_posix_output "octal 010" 'echo $((010))'
 +compare_posix_output "hex 0x10" 'echo $((0x10))'
 +compare_posix_output "hex 0xFF" 'echo $((0xFF))'
 +compare_posix_output "mixed bases" 'echo $((010 + 0x10 + 10))'
++
 +section "60. STRING LENGTH EDGE CASES"
++
 +compare_posix_output "length empty" 'X=""; echo ${#X}'
 +compare_posix_output "length one" 'X="a"; echo ${#X}'
 +compare_posix_output "length with spaces" 'X="a b c"; echo ${#X}'
 +compare_posix_output "length special chars" 'X="$@#"; echo ${#X}'
++
 +section "61. DEFAULT VALUE EDGE CASES"
++
 +compare_posix_output "default unset" 'unset X; echo ${X:-default}'
 +compare_posix_output "default null" 'X=""; echo ${X:-default}'
 +compare_posix_output "default set" 'X="value"; echo ${X:-default}'
 +compare_posix_output "no-colon unset" 'unset X; echo ${X-default}'
 +compare_posix_output "no-colon null" 'X=""; echo ${X-default}'
++
 +section "62. PATTERN REMOVAL EDGE CASES"
++
 +compare_posix_output "prefix no match" 'X="hello"; echo ${X#xyz}'
 +compare_posix_output "suffix no match" 'X="hello"; echo ${X%xyz}'
 +compare_posix_output "prefix full match" 'X="aaa"; echo ${X##a*}'
 +compare_posix_output "suffix full match" 'X="aaa"; echo ${X%%*a}'
++
 +section "63. POSITIONAL PARAMS EDGE CASES"
++
 +compare_posix_output "set clears all" 'set -- a b c; set --; echo $#'
 +compare_posix_output "set replaces" 'set -- a b; set -- x y z; echo $#'
 +compare_posix_output "shift all" 'set -- a b c; shift 3; echo $#'
++
 +section "64. EXIT STATUS PROPAGATION"
++
 +compare_posix_output "pipeline exit" 'true | true | false; echo $?'
 +compare_posix_output "subshell exit" '(exit 42); echo $?'
 +compare_posix_output "brace exit" '{ exit 7; }; echo $?'
 +compare_posix_output "command sub exit" 'X=$(exit 5); echo $?'
++
 +section "65. WORD SPLITTING IFS VARIANTS"
++
 +compare_posix_output "IFS empty no split" 'IFS=""; X="a b c"; set -- $X; echo $#'
 +compare_posix_output "IFS colon" 'IFS=":"; X="a:b:c"; set -- $X; echo $#'
 +compare_posix_output "IFS multiple" 'IFS=":;"; X="a:b;c"; set -- $X; echo $#'
 +compare_posix_output "IFS whitespace" 'IFS=" "; X="a  b  c"; set -- $X; echo $#'
 +compare_posix_output "IFS default" 'X="a   b   c"; set -- $X; echo $#'
++
 +section "66. PATHNAME EXPANSION DISABLING"
++
 +compare_posix_output "noglob off" 'touch /tmp/glob_test_a.x /tmp/glob_test_b.x 2>/dev/null; ls /tmp/glob_test_*.x 2>/dev/null | wc -l'
 +compare_posix_output "noglob on" 'set -f; echo /tmp/glob_test_*.x; set +f'
++
 +section "67. TILDE EXPANSION CONTEXTS"
++
 +compare_posix_output "tilde alone" 'echo ~ | grep -c "^/"'
 +compare_posix_output "tilde in var" 'X=~; echo $X | grep -c "^/"'
 +compare_posix_output "tilde quoted" 'echo "~" | grep -c "~"'
 +compare_posix_output "tilde in path" 'echo ~/. | grep -c "^/"'
++
 +section "68. ASSIGNMENT CONTEXTS"
++
 +compare_posix_output "simple assign" 'X=hello; echo $X'
 +compare_posix_output "assign with cmd sub" 'X=$(echo test); echo $X'
 +compare_posix_output "assign with arith" 'X=$((5+3)); echo $X'
 +compare_posix_output "multiple assign" 'X=1 Y=2 Z=3; echo $X $Y $Z'
 +compare_posix_output "assign before cmd" 'X=val sh -c "echo \$X"'
++
 +section "69. SPECIAL CHARACTER HANDLING"
++
 +compare_posix_output "escaped newline" 'echo a\
 +b'
 +compare_posix_output "escaped dollar" 'echo \$VAR'
 +compare_posix_output "escaped backslash" 'echo \\\\'
 +compare_posix_output "escaped quote" 'echo \"quoted\"'
++
 +section "70. WHILE LOOP VARIATIONS"
++
 +compare_posix_output "while with pipe" 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done | wc -l'
 +compare_posix_output "while false" 'while false; do echo never; done; echo done'
 +compare_posix_output "while break" 'i=0; while true; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i'
 +compare_posix_output "while continue" 'i=0; while [ $i -lt 5 ]; do i=$((i+1)); [ $i -eq 3 ] && continue; echo $i; done'
++
 +section "71. UNTIL LOOP VARIATIONS"
++
 +compare_posix_output "until basic" 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done'
 +compare_posix_output "until true" 'until true; do echo never; done; echo done'
 +compare_posix_output "until with break" 'i=0; until false; do i=$((i+1)); [ $i -ge 3 ] && break; done; echo $i'
++
 +section "72. FOR LOOP WORD LIST"
++
 +compare_posix_output "for with glob" 'touch /tmp/for_test_1.z /tmp/for_test_2.z 2>/dev/null; for f in /tmp/for_test_*.z; do echo found; done | wc -l'
 +compare_posix_output "for empty" 'for x in; do echo never; done; echo done'
 +compare_posix_output "for with expansion" 'X="a b c"; for i in $X; do echo $i; done | wc -l'
 +compare_posix_output "for quoted" 'for i in "a b" "c d"; do echo "[$i]"; done'
++
 +section "73. FUNCTION ARGUMENT HANDLING"
++
 +compare_posix_output "func args count" 'f() { echo $#; }; f a b c'
 +compare_posix_output "func args values" 'f() { echo $1 $2 $3; }; f x y z'
 +compare_posix_output "func args shift" 'f() { shift; echo $1; }; f a b c'
 +compare_posix_output "func args all" 'f() { echo $@; }; f 1 2 3'
 +compare_posix_output "func nested call" 'a() { b; }; b() { echo hello; }; a'
++
 +section "74. RETURN AND EXIT"
++
 +compare_posix_output "return value" 'f() { return 42; }; f; echo $?'
 +compare_posix_output "return default" 'f() { true; return; }; f; echo $?'
 +compare_posix_output "exit in subshell" '(exit 5); echo $?'
 +compare_posix_output "exit from func" 'f() { exit 7; }; f; echo never'
++
 +section "75. EVAL COMPLEX"
++
 +compare_posix_output "eval variable expansion" 'X=VAR; VAR=value; eval echo \$$X'
 +compare_posix_output "eval multiple" 'eval "A=1; B=2"; echo $A $B'
 +compare_posix_output "eval with special" 'eval "echo hello world"'
 +compare_posix_output "eval nested" 'eval eval echo test'
++
 +section "76. EXEC REDIRECTIONS"
++
 +compare_posix_output "exec redirect stdout" 'exec >/tmp/exec_test_$$; echo test; exec >&-; cat /tmp/exec_test_$$; rm /tmp/exec_test_$$'
++
 +section "77. TRAP IN SUBSHELL"
++
 +compare_posix_output "trap inherited" '(trap "echo trapped" EXIT; exit 0) 2>/dev/null'
 +compare_posix_output "trap reset in subshell" 'trap "echo outer" EXIT; (trap - EXIT; echo inner) 2>/dev/null; trap - EXIT'
++
 +section "78. COLON COMMAND"
++
 +compare_posix_output "colon returns 0" ':; echo $?'
 +compare_posix_output "colon with args" ': arg1 arg2 arg3; echo $?'
 +compare_posix_output "colon with expansion" 'X=test; : $X; echo $?'
 +compare_posix_output "colon in if" 'if :; then echo yes; fi'
++
 +section "79. DOT SOURCE"
++
 +compare_posix_output "dot sources" 'echo "X=sourced" > /tmp/dot_test_$$; . /tmp/dot_test_$$; echo $X; rm /tmp/dot_test_$$'
 +compare_posix_output "dot with args" 'echo "echo \$1" > /tmp/dot_arg_$$; . /tmp/dot_arg_$$ hello; rm /tmp/dot_arg_$$'
++
 +section "80. UNSET BEHAVIOR"
++
 +compare_posix_output "unset variable" 'X=test; unset X; echo ${X:-empty}'
 +compare_posix_output "unset function" 'f() { echo hi; }; unset -f f; f 2>/dev/null || echo gone'
 +compare_posix_output "unset nonexistent" 'unset NONEXISTENT_VAR_XYZ; echo $?'
++
 +section "81. POSIX STRING OPERATIONS"
++
 +compare_posix_output "string concat" 'A=hello; B=world; echo $A$B'
 +compare_posix_output "string in quotes" 'A="hello world"; echo "$A"'
 +compare_posix_output "string length indirect" 'A=test; echo ${#A}'
 +compare_posix_output "empty string" 'A=""; echo "[$A]"'
 +compare_posix_output "string with newline" 'A="line1
 +line2"; echo "$A" | wc -l'
++
 +section "82. POSIX NUMERIC OPERATIONS"
++
 +compare_posix_output "add subtract" 'echo $((10 - 3 + 5))'
 +compare_posix_output "multiply divide" 'echo $((20 / 4 * 2))'
 +compare_posix_output "parentheses" 'echo $(((2 + 3) * (4 + 1)))'
 +compare_posix_output "comparison chain" 'echo $((5 > 3 && 3 > 1))'
 +compare_posix_output "ternary simulation" 'X=5; [ $X -gt 3 ] && echo big || echo small'
++
 +section "83. POSIX ARRAY SIMULATION"
++
 +compare_posix_output "positional as array" 'set -- a b c d e; echo $3'
 +compare_posix_output "array length" 'set -- a b c d e; echo $#'
 +compare_posix_output "array slice" 'set -- a b c d e; shift 2; echo $1'
 +compare_posix_output "array all" 'set -- a b c; echo "$@"'
 +compare_posix_output "array iterate" 'set -- a b c; for x in "$@"; do echo $x; done'
++
 +section "84. POSIX PATTERN MATCHING"
++
 +compare_posix_output "glob question" 'touch /tmp/pat_a /tmp/pat_b 2>/dev/null; ls /tmp/pat_? 2>/dev/null | wc -l; rm -f /tmp/pat_a /tmp/pat_b'
 +compare_posix_output "glob star" 'touch /tmp/patstar_1 /tmp/patstar_2 2>/dev/null; ls /tmp/patstar_* 2>/dev/null | wc -l; rm -f /tmp/patstar_*'
 +compare_posix_output "glob bracket" 'touch /tmp/patbr_a /tmp/patbr_b 2>/dev/null; ls /tmp/patbr_[ab] 2>/dev/null | wc -l; rm -f /tmp/patbr_*'
 +compare_posix_output "case pattern star" 'x=hello; case $x in h*) echo yes;; esac'
 +compare_posix_output "case pattern question" 'x=ab; case $x in ??) echo two;; esac'
++
 +section "85. POSIX ENVIRONMENT"
++
 +compare_posix_output "HOME exists" 'echo $HOME | grep -c "^/"'
 +compare_posix_output "PATH exists" 'echo $PATH | grep -c ":"'
 +compare_posix_output "PWD exists" 'echo $PWD | grep -c "^/"'
 +compare_posix_output "export visible" 'export X=val; sh -c "echo \$X"'
 +compare_posix_output "env assignment" 'X=test sh -c "echo \$X"'
++
 +section "86. POSIX SPECIAL EXPANSIONS"
++
 +compare_posix_output "dollar dollar" 'echo $$ | grep -E "^[0-9]+$" | wc -l'
 +compare_posix_output "dollar question" 'true; echo $?'
 +compare_posix_output "dollar bang" 'sleep 0.01 & echo $! | grep -E "^[0-9]+$" | wc -l; wait'
 +compare_posix_output "dollar hash" 'set -- a b c; echo $#'
 +compare_posix_output "dollar zero" 'echo $0 | wc -c | xargs test 0 -lt && echo yes'
++
 +section "87. POSIX ERROR HANDLING"
++
 +compare_posix_output "command not found" 'nonexistent_cmd_xyz 2>/dev/null; echo $?'
 +compare_posix_output "file not found" 'cat /nonexistent_file_xyz 2>/dev/null; echo $?'
 +compare_posix_output "permission denied sim" 'test -r /etc/shadow 2>/dev/null; echo done'
 +compare_posix_output "syntax error handled" 'eval "if" 2>/dev/null; echo recovered'
++
 +section "88. POSIX CONDITIONAL CHAINS"
++
 +compare_posix_output "if and" 'if true && true; then echo yes; fi'
 +compare_posix_output "if or" 'if false || true; then echo yes; fi'
 +compare_posix_output "if not" 'if ! false; then echo yes; fi'
 +compare_posix_output "complex condition" 'X=5; if [ $X -gt 3 ] && [ $X -lt 10 ]; then echo range; fi'
 +compare_posix_output "elif chain long" 'X=4; if [ $X -eq 1 ]; then echo 1; elif [ $X -eq 2 ]; then echo 2; elif [ $X -eq 3 ]; then echo 3; elif [ $X -eq 4 ]; then echo 4; fi'
++
 +section "89. POSIX INPUT PROCESSING"
++
 +compare_posix_output "read line" 'echo "hello" | { read x; echo $x; }'
 +compare_posix_output "read words" 'echo "a b c" | { read x y z; echo $y; }'
 +compare_posix_output "read with IFS" 'echo "a:b:c" | { IFS=: read x y z; echo $y; }'
 +compare_posix_output "cat file" 'echo "test" > /tmp/read_test_$$; cat /tmp/read_test_$$; rm /tmp/read_test_$$'
++
 +section "90. POSIX OUTPUT FORMATTING"
++
 +compare_posix_output "printf string" 'printf "%s\n" "hello"'
 +compare_posix_output "printf number" 'printf "%d\n" 42'
 +compare_posix_output "printf hex" 'printf "%x\n" 255'
 +compare_posix_output "printf octal" 'printf "%o\n" 64'
 +compare_posix_output "printf char" 'printf "%c\n" A'
 +compare_posix_output "echo no newline" 'printf "no newline"'
++
 +# Summary
 +printf "\n"
 +printf "==========================================\n"
 +printf "EXTENDED POSIX COMPLIANCE TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +if [ $((PASSED + FAILED)) -gt 0 ]; then
 +    PASS_RATE=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%%\n" "$PASS_RATE"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL EXTENDED POSIX TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_compliance_filetest.shadded

1108 lines changed — click to load

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance File Test Operators Suite for fortsh
 +# =====================================
 +# Tests test/[ builtin file and string operators per IEEE Std 1003.1-2017
 +# Section: Shell Command Language - Conditional Expressions
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-filetest]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Create test directory with test files
 +setup_test_files() {
 +    TEST_DIR="/tmp/fortsh_filetest_$$"
 +    mkdir -p "$TEST_DIR"
 +    cd "$TEST_DIR" || exit 1
++
 +    # Create various test files
 +    echo "content" > regular_file
 +    mkdir test_dir
 +    touch empty_file
 +    chmod 755 executable_file 2>/dev/null || touch executable_file
 +    chmod +x executable_file 2>/dev/null
 +    chmod 000 unreadable_file 2>/dev/null || touch unreadable_file
 +    ln -s regular_file symlink_file 2>/dev/null
 +    ln -s nonexistent broken_link 2>/dev/null
 +    mkfifo named_pipe 2>/dev/null || true
 +}
++
 +cleanup_test_files() {
 +    cd /
 +    chmod 644 "$TEST_DIR/unreadable_file" 2>/dev/null
 +    rm -rf "$TEST_DIR"
 +}
++
 +# Trap to ensure cleanup
 +trap cleanup_test_files EXIT
++
 +setup_test_files
++
 +# =====================================
 +section "369. FILE EXISTENCE AND TYPE TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ -d file ] returns false for file"
 +else
 +    fail "[ -d file ] returns false for file" "no" "$result"
 +fi
++
 +# =====================================
 +section "370. SYMBOLIC LINK TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -L broken_link ] true for broken symlink"
 +else
 +    fail "[ -L broken_link ] true for broken symlink" "yes" "$result"
 +fi
++
 +# =====================================
 +section "371. FILE PERMISSION TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ -x non-exec ] returns false"
 +else
 +    fail "[ -x non-exec ] returns false" "no" "$result"
 +fi
++
 +# =====================================
 +section "372. FILE SIZE TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "no" ]; then
 +    pass "[ -s empty ] returns false for empty file"
 +else
 +    fail "[ -s empty ] returns false for empty file" "no" "$result"
 +fi
++
 +# =====================================
 +section "373. STRING TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ \"\" ] empty string is false"
 +else
 +    fail "[ \"\" ] empty string is false" "no" "$result"
 +fi
++
 +# =====================================
 +section "374. STRING COMPARISON TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ str != str ] returns false for same"
 +else
 +    fail "[ str != str ] returns false for same" "no" "$result"
 +fi
++
 +# =====================================
 +section "375. NUMERIC COMPARISON TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ n1 -le n2 ] less or equal (less)"
 +else
 +    fail "[ n1 -le n2 ] less or equal (less)" "yes" "$result"
 +fi
++
 +# =====================================
 +section "376. LOGICAL OPERATORS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ expr -o expr ] logical OR (both false)"
 +else
 +    fail "[ expr -o expr ] logical OR (both false)" "no" "$result"
 +fi
++
 +# =====================================
 +section "377. FILE COMPARISON TESTS"
 +# =====================================
++
 +# Create files with different timestamps
 +touch "$TEST_DIR/older_file"
 +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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ f -ef f ] same file test"
 +else
 +    fail "[ f -ef f ] same file test" "yes" "$result"
 +fi
++
 +# =====================================
 +section "378. TEST COMMAND FORM"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "test n1 -gt n2 (test command form)"
 +else
 +    fail "test n1 -gt n2 (test command form)" "yes" "$result"
 +fi
++
 +# =====================================
 +section "379. SPECIAL FILE TYPES"
 +# =====================================
++
 +# 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)
 +    if [ "$result" = "yes" ]; then
 +        pass "[ -p fifo ] named pipe test"
 +    else
 +        fail "[ -p fifo ] named pipe test" "yes" "$result"
 +    fi
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ -p regular ] returns false for non-pipe"
 +else
 +    fail "[ -p regular ] returns false for non-pipe" "no" "$result"
 +fi
++
 +# Terminal test
 +result=$("$FORTSH_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"
 +else
 +    fail "[ -t 0 ] non-terminal stdin" "no" "$result"
 +fi
++
 +# =====================================
 +section "380. EDGE CASES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ \"-n\" = \"-n\" ] operator as string"
 +else
 +    fail "[ \"-n\" = \"-n\" ] operator as string" "yes" "$result"
 +fi
++
 +# =====================================
 +section "381. COMPLEX TEST EXPRESSIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ ! expr ] negates true"
 +else
 +    fail "[ ! expr ] negates true" "no" "$result"
 +fi
++
 +# =====================================
 +section "382. PARENTHESES IN TEST"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ \\( a -o b \\) -a c ] complex grouping"
 +else
 +    fail "[ \\( a -o b \\) -a c ] complex grouping" "yes" "$result"
 +fi
++
 +# =====================================
 +section "383. STRING LENGTH COMPARISONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -n \"abc\" ] string has length"
 +else
 +    fail "[ -n \"abc\" ] string has length" "yes" "$result"
 +fi
++
 +# =====================================
 +section "384. NUMERIC EDGE CASES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ large -gt 1 ] large numbers"
 +else
 +    fail "[ large -gt 1 ] large numbers" "yes" "$result"
 +fi
++
 +# =====================================
 +section "385. STRING VS NUMERIC"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +# Numeric comparison - may or may not treat 010 as octal
 +if [ "$result" = "yes" ] || [ "$result" = "no" ]; then
 +    pass "[ 10 -eq 010 ] numeric comparison"
 +else
 +    fail "[ 10 -eq 010 ] numeric comparison" "yes or no" "$result"
 +fi
++
 +# =====================================
 +section "386. FILE TEST WITH VARIABLES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -d \"\$var\" ] variable as dirname"
 +else
 +    fail "[ -d \"\$var\" ] variable as dirname" "yes" "$result"
 +fi
++
 +# =====================================
 +section "387. EMPTY OPERAND HANDLING"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ \"\$unset\" = \"\" ] unset equals empty"
 +else
 +    fail "[ \"\$unset\" = \"\" ] unset equals empty" "yes" "$result"
 +fi
++
 +# =====================================
 +section "388. NUMERIC COMPARISON OPERATORS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ 3 -le 3 ] less or equal"
 +else
 +    fail "[ 3 -le 3 ] less or equal" "yes" "$result"
 +fi
++
 +# =====================================
 +section "389. NEGATIVE NUMBER TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -5 -eq -5 ] negative equality"
 +else
 +    fail "[ -5 -eq -5 ] negative equality" "yes" "$result"
 +fi
++
 +# =====================================
 +section "390. STRING TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ \"xyz\" > \"abc\" ] string greater than"
 +else
 +    fail "[ \"xyz\" > \"abc\" ] string greater than" "yes" "$result"
 +fi
++
 +# =====================================
 +section "391. FILE PERMISSION TESTS"
 +# =====================================
++
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -w file ] writable file"
 +else
 +    fail "[ -w file ] writable file" "yes" "$result"
 +fi
++
 +# =====================================
 +section "392. TEST BUILTIN vs [ COMMAND"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "test string equality"
 +else
 +    fail "test string equality" "yes" "$result"
 +fi
++
 +# =====================================
 +section "393. COMBINED LOGICAL TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "! [ ] negation"
 +else
 +    fail "! [ ] negation" "yes" "$result"
 +fi
++
 +# =====================================
 +section "394. FILE TYPE TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "no" ]; then
 +    pass "[ -e /nonexistent ] does not exist"
 +else
 +    fail "[ -e /nonexistent ] does not exist" "no" "$result"
 +fi
++
 +# =====================================
 +section "395. FILE SIZE TESTS"
 +# =====================================
++
 +echo "content" > "$TEST_DIR/nonempty.txt"
 +result=$("$FORTSH_BIN" -c '[ -s "'"$TEST_DIR"'/nonempty.txt" ] && echo yes || echo no' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -s file ] non-empty file"
 +else
 +    fail "[ -s file ] non-empty file" "yes" "$result"
 +fi
++
 +: > "$TEST_DIR/empty.txt"
 +result=$("$FORTSH_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
 +    fail "[ -s file ] empty file is false" "no" "$result"
 +fi
++
 +# =====================================
 +section "396. SYMLINK TESTS"
 +# =====================================
++
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ -h symlink ] is symlink (alternate)"
 +else
 +    fail "[ -h symlink ] is symlink (alternate)" "yes" "$result"
 +fi
++
 +# =====================================
 +section "397. SPECIAL FILE TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "no" ]; then
 +    pass "[ -p /dev/null ] not a pipe"
 +else
 +    fail "[ -p /dev/null ] not a pipe" "no" "$result"
 +fi
++
 +# =====================================
 +section "398. TERMINAL TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    fail "[ -t 1 ] terminal test runs"
 +fi
++
 +# =====================================
 +section "399. COMPOUND EXPRESSION PRECEDENCE"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "yes" ]; then
 +    pass "|| then && precedence"
 +else
 +    fail "|| then && precedence" "yes" "$result"
 +fi
++
 +# =====================================
 +section "400. EDGE CASE EXPRESSIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "[ ! \"\" ] negated empty is true"
 +else
 +    fail "[ ! \"\" ] negated empty is true" "yes" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX File Test Operators Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_gaps.shadded

2802 lines changed — click to load

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Gap Coverage Test Suite
 +# =====================================
 +# This test file specifically targets gaps in the existing 4 POSIX test files
 +# by comparing against IEEE Std 1003.1-2017 (POSIX.1-2017)
 +#
 +# Focus areas:
 +# - Here-document variations (<<- tab stripping)
 +# - Additional redirection operators (<>)
 +# - Complex IFS field splitting scenarios
 +# - Nested and complex parameter expansions
 +# - Command name resolution order
 +# - Complex quoting and escaping
 +# - Pipeline exit status rules
 +# - Complex arithmetic edge cases
 +# - Locale and environment variables
 +# - Builtin command edge cases
 +# - Pathname expansion edge cases
 +# - Function scope and recursion edge cases
 +# - Signal handling edge cases
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-gaps]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
 +DEBUG_INFO=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "91. HERE DOCUMENT VARIATIONS"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# 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]*: //'
 +}
++
 +# Helper function to run command in both shells and compare
 +compare_posix_output() {
 +    test_name="$1"
 +    command="$2"
 +    posix_file="/tmp/posix_gaps_$$_posix"
 +    fortsh_file="/tmp/posix_gaps_$$_fortsh"
++
 +    # Run in POSIX shell (sh)
 +    "$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
++
 +    # Compare outputs
 +    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +    fi
++
 +    rm -f "$posix_file" "$fortsh_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]*: //'
 +}
++
 +# Compare error output, normalizing line number differences
 +compare_posix_error() {
 +    test_name="$1"
 +    command="$2"
 +    posix_file="/tmp/posix_gaps_$$_posix"
 +    fortsh_file="/tmp/posix_gaps_$$_fortsh"
++
 +    # Run in POSIX shell (sh)
 +    "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
++
 +    # Run in fortsh
 +    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
++
 +    # Normalize error messages before comparison
 +    posix_norm=$(normalize_error "$(cat "$posix_file")")
 +    fortsh_norm=$(normalize_error "$(cat "$fortsh_file")")
++
 +    if [ "$posix_norm" = "$fortsh_norm" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +    fi
++
 +    rm -f "$posix_file" "$fortsh_file"
 +}
++
 +# Helper function to compare exit codes
 +compare_posix_exit_code() {
 +    test_name="$1"
 +    command="$2"
++
 +    "$BASH_REF" -c "$command" > /dev/null 2>&1
 +    posix_exit=$?
++
 +    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    fortsh_exit=$?
++
 +    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_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"
 +    fi
 +}
++
 +# Cleanup
 +cleanup() {
 +    rm -f /tmp/posix_gaps_$$_* 2>/dev/null
 +    rm -rf /tmp/posix_gaps_test_* 2>/dev/null
 +}
 +trap cleanup EXIT INT TERM
++
 +section "97. PIPELINE EXIT STATUS"
++
 +compare_posix_exit_code "pipeline last command status" "true | true | false"
 +compare_posix_exit_code "pipeline first fails" "false | true | true"
 +compare_posix_exit_code "pipeline middle fails" "true | false | true"
 +compare_posix_output "PIPESTATUS concept" "false | true | true; echo \$?"
++
 +section "99. PATHNAME EXPANSION EDGE CASES"
++
 +mkdir -p /tmp/posix_gaps_test_glob
 +touch "/tmp/posix_gaps_test_glob/file1.txt"
 +touch "/tmp/posix_gaps_test_glob/file2.txt"
 +touch "/tmp/posix_gaps_test_glob/file[3].txt"
 +touch "/tmp/posix_gaps_test_glob/-file.txt"
 +mkdir -p "/tmp/posix_gaps_test_glob/.hidden"
++
 +compare_posix_output "glob bracket literal" "ls /tmp/posix_gaps_test_glob/file[[]3].txt 2>/dev/null | wc -l"
 +compare_posix_output "glob dash in bracket" "ls /tmp/posix_gaps_test_glob/[-a-z]file.txt 2>/dev/null | wc -l"
 +compare_posix_output "glob no match returns literal" "echo /tmp/posix_gaps_test_glob/*.xyz | grep -c '\\*'"
 +compare_posix_output "glob hidden dirs" "ls -d /tmp/posix_gaps_test_glob/.* 2>/dev/null | grep -c hidden"
 +compare_posix_output "glob character class digit" "touch /tmp/posix_gaps_test_glob/f1.txt; ls /tmp/posix_gaps_test_glob/f[[:digit:]].txt 2>/dev/null | wc -l"
++
 +rm -rf /tmp/posix_gaps_test_glob
++
 +section "100. FUNCTION SCOPE AND RECURSION EDGE CASES"
++
 +compare_posix_output "function local scope via subshell" "f() { (X=inner; echo \$X); }; X=outer; f; echo \$X"
 +compare_posix_output "function positional params" "f() { echo \$1 \$2; }; set -- a b; f x y"
 +compare_posix_output "function preserves positional" "f() { echo \$1; }; set -- a b; f x; echo \$1"
 +compare_posix_output "nested function calls" "a() { b; }; b() { c; }; c() { echo deep; }; a"
 +compare_posix_output "function return in subshell" "f() { (return 5); echo \$?; }; f"
 +compare_posix_output "recursive factorial" "fact() { if [ \$1 -le 1 ]; then echo 1; else local r=\$(fact \$((\$1-1)) 2>/dev/null || fact \$((\$1-1))); echo \$((\$1 * r)); fi; }; fact 4"
++
 +section "101. EXIT STATUS IN COMPOUND COMMANDS"
++
 +compare_posix_exit_code "subshell exit status" "(exit 42); echo \$?"
 +compare_posix_exit_code "brace group exit status" "{ exit 42; }; echo \$?"
 +compare_posix_exit_code "if statement exit status" "if true; then true; fi; echo \$?"
 +compare_posix_exit_code "for loop exit status" "for i in 1; do false; done; echo \$?"
 +compare_posix_exit_code "while loop exit status" "while false; do :; done; echo \$?"
 +compare_posix_exit_code "case exit status" "case x in x) false;; esac; echo \$?"
++
 +section "114. ALIAS EDGE CASES"
++
 +compare_posix_output "alias with args" "alias ll='ls -l'; alias ll | grep -c 'ls -l'"
 +compare_posix_output "alias recursive prevention" "alias ls='ls -a'; command ls /tmp >/dev/null; echo \$?"
 +compare_posix_output "unalias nonexistent" "unalias nonexistent_alias_$$ 2>/dev/null || echo ok"
 +compare_posix_output "alias name same as builtin" "alias echo='printf'; unalias echo; command -v echo | grep -c echo"
++
 +section "115. TEST COMMAND COMPLEX EXPRESSIONS"
++
 +compare_posix_exit_code "test complex AND/OR" "test 5 -gt 3 -a \( 10 -lt 20 -o 1 -eq 2 \)"
 +compare_posix_exit_code "test negation precedence" "test ! 5 -gt 10"
 +compare_posix_exit_code "test string empty" "test -z ''"
 +compare_posix_exit_code "test string nonempty" "test -n 'x'"
 +compare_posix_exit_code "test string unary" "test 'nonempty'"
++
 +section "118. COMMAND SUBSTITUTION EDGE CASES"
++
 +compare_posix_output "command subst nested" "echo \$(echo \$(echo nested))"
 +compare_posix_output "command subst with pipes" "echo \$(echo a | cat)"
 +compare_posix_output "command subst multiline" "result=\$(echo a; echo b); echo \"\$result\" | wc -l"
 +compare_posix_output "command subst empty" "x=\$(true); echo \"|\$x|\""
 +compare_posix_output "backtick vs dollar-paren" "a=\`echo test\`; b=\$(echo test); test \"\$a\" = \"\$b\" && echo same"
++
 +section "130. EXPORT EDGE CASES"
++
 +compare_posix_output "export without value" "export VAR; sh -c 'echo \${VAR:-unset}'"
 +compare_posix_output "export with value" "export VAR=value; sh -c 'echo \$VAR'"
 +compare_posix_output "export multiple" "export A=1 B=2; sh -c 'echo \$A \$B'"
 +compare_posix_output "export readonly" "readonly X=ro; export X; sh -c 'echo \$X'"
++
 +section "131. VARIABLE SCOPE EDGE CASES"
++
 +compare_posix_output "var in subshell lost" 'X=1; (X=2); echo $X'
 +compare_posix_output "var in brace group kept" 'X=1; { X=2; }; echo $X'
 +compare_posix_output "env var in subshell" 'export X=1; (echo $X)'
 +compare_posix_output "command prefix assignment" 'X=val sh -c "echo \$X"'
++
 +section "132. FUNCTION VARIABLE SCOPE"
++
 +compare_posix_output "global in function" 'X=global; f() { echo $X; }; f'
 +compare_posix_output "function modifies global" 'X=1; f() { X=2; }; f; echo $X'
 +compare_posix_output "local shadows global" 'X=1; f() { local X=2; echo $X; }; f; echo $X'
++
 +section "134. COMMAND SUBSTITUTION EDGE CASES"
++
 +compare_posix_output "nested cmd sub" 'echo $(echo $(echo deep))'
 +compare_posix_output "cmd sub with quotes" 'echo "$(echo "hello world")"'
 +compare_posix_output "cmd sub trailing newline" 'x=$(printf "hi\n"); echo "[$x]"'
 +compare_posix_output "backtick substitution" 'echo `echo hello`'
++
 +section "137. WORD SPLITTING EDGE CASES"
++
 +compare_posix_output "IFS colon split" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "IFS multiple chars" 'IFS=":;"; x="a:b;c"; set -- $x; echo $#'
 +compare_posix_output "empty IFS no split" 'IFS=""; x="a b c"; set -- $x; echo $#'
 +compare_posix_output "default IFS" 'unset IFS; x="a   b"; set -- $x; echo $#'
++
 +section "138. GLOB EDGE CASES"
++
 +compare_posix_output "glob no match" 'echo /nonexistent_dir_xyz_$$/* 2>/dev/null | grep -c nonexistent || echo "0 or pattern"'
 +compare_posix_output "set -f disables glob" 'set -f; echo *; set +f'
 +compare_posix_output "quoted glob literal" 'echo "*"'
++
 +section "139. SIGNAL EDGE CASES"
++
 +compare_posix_output "trap list" 'trap "echo x" INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap reset" 'trap "echo x" INT; trap - INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap EXIT runs" 'sh -c "trap echo_exit EXIT; exit 0" 2>/dev/null; echo done'
++
 +section "140. MISCELLANEOUS EDGE CASES"
++
 +compare_posix_output "empty for list" 'for x in; do echo x; done; echo done'
 +compare_posix_output "case no match" 'case x in y) echo y;; esac; echo done'
 +compare_posix_output "if false branch" 'if false; then echo yes; else echo no; fi'
 +compare_posix_output "elif chain" 'if false; then echo 1; elif false; then echo 2; else echo 3; fi'
 +compare_posix_output "nested if" 'if true; then if true; then echo nested; fi; fi'
++
 +section "141. ADDITIONAL EDGE CASES"
++
 +compare_posix_output "while zero iterations" 'while false; do echo never; done; echo done'
 +compare_posix_output "until zero iterations" 'until true; do echo never; done; echo done'
 +compare_posix_output "function empty body" 'f() { :; }; f; echo $?'
 +compare_posix_output "pipeline single" 'echo test | cat'
 +compare_posix_output "assignment no space" 'x=value; echo $x'
 +compare_posix_output "comment mid-line" 'echo visible # hidden'
 +compare_posix_output "newline continuation" 'echo hel\
 +lo'
 +compare_posix_output "mixed operators" 'true && false || echo fallback'
++
 +section "142. ADDITIONAL GAPS"
++
 +compare_posix_output "expr string length" 'expr length "hello"'
 +compare_posix_output "test with and" '[ 1 -eq 1 ] && [ 2 -eq 2 ] && echo both'
 +compare_posix_output "test with or" '[ 1 -eq 2 ] || [ 2 -eq 2 ] && echo one'
 +compare_posix_output "double negation" '! ! true && echo yes'
 +compare_posix_output "triple pipe" 'echo test | cat | cat | cat'
 +compare_posix_output "var in quotes" 'X="hello world"; echo "$X"'
 +compare_posix_output "arithmetic compare" 'echo $((5 > 3))'
 +compare_posix_output "arithmetic ternary sim" '[ 5 -gt 3 ] && echo big || echo small'
 +compare_posix_output "for with seq" 'for i in 1 2 3 4 5; do echo $i; done | wc -l'
 +compare_posix_output "while decrement" 'i=5; while [ $i -gt 0 ]; do i=$((i-1)); done; echo $i'
 +compare_posix_output "case star pattern" 'x=anything; case $x in *) echo star;; esac'
 +compare_posix_output "func recursion base" 'f() { [ $1 -le 0 ] && echo done || f $(($1-1)); }; f 3'
 +compare_posix_output "heredoc simple" 'cat <<END
 +test
 +END'
 +compare_posix_output "redirect both" 'echo out; echo err >&2'
 +compare_posix_output "subshell cd" '(cd /tmp; pwd)'
++
 +section "151. FUNCTION PATTERNS"
++
 +compare_posix_output "func define call" 'f() { echo hello; }; f'
 +compare_posix_output "func with args" 'f() { echo $1 $2; }; f a b'
 +compare_posix_output "func return code" 'f() { return 0; }; f; echo $?'
 +compare_posix_output "func return 1" 'f() { return 1; }; f; echo $?'
 +compare_posix_output "func with local" 'x=outer; f() { x=inner; }; f; echo $x'
 +compare_posix_output "func recursive" 'f() { [ $1 -eq 0 ] && echo done || f $(($1-1)); }; f 2'
 +compare_posix_output "func in pipeline" 'f() { echo test; }; f | cat'
 +compare_posix_output "func multi stmt" 'f() { echo a; echo b; }; f | wc -l'
 +compare_posix_output "func empty body" 'f() { :; }; f; echo ok'
 +compare_posix_output "func all args" 'f() { echo $@; }; f a b c'
++
 +section "152. REDIRECTION PATTERNS"
++
 +compare_posix_output "redir output" 'echo test > /tmp/test_$$; cat /tmp/test_$$; rm /tmp/test_$$'
 +compare_posix_output "redir append" 'echo a > /tmp/test_$$; echo b >> /tmp/test_$$; wc -l < /tmp/test_$$; rm /tmp/test_$$'
 +compare_posix_output "redir input" 'echo test > /tmp/test_$$; cat < /tmp/test_$$; rm /tmp/test_$$'
 +compare_posix_output "redir stderr" 'echo err >&2 2>/dev/null; echo ok'
 +compare_posix_output "redir both devnull" 'echo out; echo err >&2 2>/dev/null'
 +compare_posix_output "redir fd dup" 'echo test 2>&1 | cat'
 +compare_posix_output "redir here string alt" 'echo test | cat'
 +compare_posix_output "redir noclobber safe" 'echo ok'
 +compare_posix_output "multiple redir" 'echo a; echo b; echo c'
 +compare_posix_output "redir in subshell" '(echo test > /tmp/test_$$); cat /tmp/test_$$ 2>/dev/null; rm /tmp/test_$$ 2>/dev/null; echo done'
++
 +section "153. SPECIAL PARAMETERS"
++
 +compare_posix_output "dollar question" 'true; echo $?'
 +compare_posix_output "dollar question fail" 'false; echo $?'
 +compare_posix_output "dollar hyphen" 'echo $- | grep -c "."'
 +compare_posix_output "dollar dollar" 'echo $$ | grep -c "[0-9]"'
 +compare_posix_output "dollar zero" 'echo ${0:-shell} | grep -c "."'
 +compare_posix_output "positional one" 'set -- a b c; echo $1'
 +compare_posix_output "positional two" 'set -- a b c; echo $2'
 +compare_posix_output "positional three" 'set -- a b c; echo $3'
 +compare_posix_output "dollar at" 'set -- a b c; echo "$@"'
 +compare_posix_output "dollar star" 'set -- a b c; echo "$*"'
++
 +section "154. TEST BUILTIN COMPREHENSIVE"
++
 +compare_posix_output "test eq" '[ 1 -eq 1 ]; echo $?'
 +compare_posix_output "test ne" '[ 1 -ne 2 ]; echo $?'
 +compare_posix_output "test lt" '[ 1 -lt 2 ]; echo $?'
 +compare_posix_output "test gt" '[ 2 -gt 1 ]; echo $?'
 +compare_posix_output "test le" '[ 1 -le 1 ]; echo $?'
 +compare_posix_output "test ge" '[ 1 -ge 1 ]; echo $?'
 +compare_posix_output "test str eq" '[ "a" = "a" ]; echo $?'
 +compare_posix_output "test str ne" '[ "a" != "b" ]; echo $?'
 +compare_posix_output "test z" '[ -z "" ]; echo $?'
 +compare_posix_output "test n" '[ -n "x" ]; echo $?'
++
 +section "155. FILE TEST OPERATIONS"
++
 +compare_posix_output "test f file" '[ -f /etc/passwd ] && echo yes || echo no'
 +compare_posix_output "test d dir" '[ -d /tmp ] && echo yes || echo no'
 +compare_posix_output "test e exists" '[ -e /tmp ] && echo yes || echo no'
 +compare_posix_output "test r read" '[ -r /etc/passwd ] && echo yes || echo no'
 +compare_posix_output "test w write" '[ -w /tmp ] && echo yes || echo no'
 +compare_posix_output "test x exec" '[ -x /bin/sh ] && echo yes || echo no'
 +compare_posix_output "test s size" '[ -s /etc/passwd ] && echo yes || echo no'
 +compare_posix_output "test not exist" '[ -e /nonexistent_xyz ] && echo yes || echo no'
 +compare_posix_output "test not dir" '[ -d /etc/passwd ] && echo yes || echo no'
 +compare_posix_output "test not file" '[ -f /tmp ] && echo yes || echo no'
++
 +section "156. LOGICAL COMBINATIONS"
++
 +compare_posix_output "and true true" 'true && true; echo $?'
 +compare_posix_output "and true false" 'true && false; echo $?'
 +compare_posix_output "and false true" 'false && true; echo $?'
 +compare_posix_output "and false false" 'false && false; echo $?'
 +compare_posix_output "or true true" 'true || true; echo $?'
 +compare_posix_output "or true false" 'true || false; echo $?'
 +compare_posix_output "or false true" 'false || true; echo $?'
 +compare_posix_output "or false false" 'false || false; echo $?'
 +compare_posix_output "not true" '! true; echo $?'
 +compare_posix_output "not false" '! false; echo $?'
++
 +section "157. SUBSHELL AND GROUPING"
++
 +compare_posix_output "subshell basic" '(echo sub)'
 +compare_posix_output "subshell var scope" 'x=outer; (x=inner); echo $x'
 +compare_posix_output "subshell exit" '(exit 5); echo $?'
 +compare_posix_output "subshell cd scope" '(cd /tmp); pwd | grep -v "/tmp" | head -1'
 +compare_posix_output "brace group" '{ echo brace; }'
 +compare_posix_output "brace group var" 'x=outer; { x=inner; }; echo $x'
 +compare_posix_output "brace group list" '{ echo a; echo b; } | wc -l'
 +compare_posix_output "subshell nested" '(echo $(echo nested))'
 +compare_posix_output "mixed grouping" '(echo sub); { echo brace; }'
 +compare_posix_output "subshell pipeline" '(echo test) | cat'
++
 +section "158. HEREDOC PATTERNS"
++
 +compare_posix_output "heredoc basic" 'cat <<EOF
 +test
 +EOF'
 +compare_posix_output "heredoc multi" 'cat <<EOF
 +line1
 +line2
 +EOF'
 +compare_posix_output "heredoc expand" 'X=val; cat <<EOF
 +$X
 +EOF'
 +compare_posix_output "heredoc quoted" "cat <<'EOF'
 +\$X
 +EOF"
 +compare_posix_output "heredoc tab" 'cat <<-EOF
 +	indented
 +EOF'
 +compare_posix_output "heredoc empty" 'cat <<EOF
 +EOF
 +echo done'
 +compare_posix_output "heredoc special" 'cat <<EOF
 +* $ " '"'"'
 +EOF'
++
 +section "159. QUOTING EDGE CASES"
++
 +compare_posix_output "double quote var" 'x=val; echo "$x"'
 +compare_posix_output "single quote literal" "echo 'literal \$x'"
 +compare_posix_output "escape in double" 'echo "a\\b"'
 +compare_posix_output "dollar literal" 'echo "\$"'
 +compare_posix_output "backtick literal" 'echo "\`"'
 +compare_posix_output "newline in quote" 'echo "line1
 +line2"'
 +compare_posix_output "tab in quote" 'echo "a	b"'
 +compare_posix_output "space preservation" 'echo "a   b"'
 +compare_posix_output "empty string" 'echo ""'
 +compare_posix_output "adjacent quotes" 'echo "a""b"'
++
 +section "160. EXPANSION ORDER"
++
 +compare_posix_output "tilde first" 'echo ~ | grep -c "/"'
 +compare_posix_output "param before cmd" 'x=echo; $x hello'
 +compare_posix_output "arith in var" 'x=$((1+1)); echo $x'
 +compare_posix_output "cmd in arith" 'echo $(($(echo 5) + 1))'
 +compare_posix_output "var in glob" 'x="*"; echo "$x"'
 +compare_posix_output "split then glob" 'IFS=" "; x="a b"; for i in $x; do echo $i; done | wc -l'
 +compare_posix_output "quote prevents split" 'x="a b c"; set -- "$x"; echo $#'
 +compare_posix_output "unquote allows split" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "nested expansion" 'x=y; y=val; eval echo \$$x'
 +compare_posix_output "complex chain" 'x=$(echo $((1+2))); echo $x'
++
 +section "161. BUILTIN COMMAND VARIATIONS"
++
 +compare_posix_output "echo no newline" 'echo -n test; echo done'
 +compare_posix_output "echo escape e" 'echo -e "a\tb"'
 +compare_posix_output "printf string" 'printf "%s\n" hello'
 +compare_posix_output "printf number" 'printf "%d\n" 42'
 +compare_posix_output "printf hex" 'printf "%x\n" 255'
 +compare_posix_output "printf octal" 'printf "%o\n" 64'
 +compare_posix_output "printf width" 'printf "%5d\n" 42'
 +compare_posix_output "printf zero pad" 'printf "%05d\n" 42'
 +compare_posix_output "printf left align" 'printf "%-5d|\n" 42'
 +compare_posix_output "printf multiple" 'printf "%s %s\n" a b'
++
 +section "162. PRINTF VARIATIONS"
++
 +compare_posix_output "printf basic" 'printf "hello\n"'
 +compare_posix_output "printf no newline" 'printf "test"; echo done'
 +compare_posix_output "printf format s" 'printf "%s\n" hello'
 +compare_posix_output "printf format d" 'printf "%d\n" 42'
 +compare_posix_output "printf multi arg" 'printf "%s %s\n" a b'
 +compare_posix_output "printf width" 'printf "%5s\n" ab'
 +compare_posix_output "printf escape" 'printf "a\tb\n"'
 +compare_posix_output "printf percent" 'printf "%%\n"'
++
 +section "163. SET BUILTIN VARIATIONS"
++
 +compare_posix_output "set positional" 'set -- a b c; echo $1 $2 $3'
 +compare_posix_output "set clear" 'set -- a b; set --; echo ${1:-none}'
 +compare_posix_output "set e exit" 'set -e; true; echo ok'
 +compare_posix_output "set u unset" 'set +u; echo ${undefined_var:-default}'
 +compare_posix_output "set f noglob" 'set -f; echo *; set +f'
 +compare_posix_output "set minus" 'echo $-'
 +compare_posix_output "set show" 'X=1; set | grep -c "^X=" || echo 0'
 +compare_posix_output "shift once" 'set -- a b c; shift; echo $1'
 +compare_posix_output "shift twice" 'set -- a b c; shift 2; echo $1'
 +compare_posix_output "shift all" 'set -- a b; shift 2; echo ${1:-empty}'
++
 +section "164. EXPORT AND ENV"
++
 +compare_posix_output "export simple" 'export X=val; echo $X'
 +compare_posix_output "export existing" 'X=val; export X; echo $X'
 +compare_posix_output "export list" 'export X=1 Y=2; echo $X $Y'
 +compare_posix_output "export subshell" 'export X=val; (echo $X)'
 +compare_posix_output "env prefix" 'X=override sh -c "echo \$X"'
 +compare_posix_output "env clear" 'X=val; unset X; echo ${X:-unset}'
 +compare_posix_output "readonly var" 'readonly X=const; echo $X'
 +compare_posix_output "unset normal" 'X=val; unset X; echo ${X:-gone}'
++
 +section "165. TRAP VARIATIONS"
++
 +# Note: Initial trap state may vary by environment - check both produce some output
 +compare_posix_exit_code "trap list empty" 'trap >/dev/null 2>&1'
 +compare_posix_output "trap set list" 'trap "echo x" INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap reset" 'trap "echo x" INT; trap - INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap exit" 'sh -c "trap \"echo exit\" EXIT" 2>/dev/null || echo done'
 +compare_posix_output "trap ignore" 'trap "" INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap in func" 'f() { trap "echo trap" EXIT; }; f 2>/dev/null; echo done'
++
 +section "166. EVAL AND EXEC"
++
 +compare_posix_output "eval simple" 'eval echo hello'
 +compare_posix_output "eval var" 'X=world; eval echo hello $X'
 +compare_posix_output "eval cmd" 'eval "echo test"'
 +compare_posix_output "eval multi" 'eval "echo a; echo b"'
 +compare_posix_output "eval indirect" 'X=Y; Y=val; eval echo \$$X'
 +compare_posix_output "exec redirect" 'exec 3>&1; echo test >&3'
 +compare_posix_output "exec close" 'exec 3>&1; exec 3>&-; echo ok'
++
 +section "167. DOT AND SOURCE"
++
 +compare_posix_output "dot inline" 'echo "X=sourced" > /tmp/src_$$; . /tmp/src_$$; echo $X; rm /tmp/src_$$'
 +compare_posix_output "dot func" 'echo "f() { echo func; }" > /tmp/src_$$; . /tmp/src_$$; f; rm /tmp/src_$$'
 +compare_posix_output "dot var persist" 'echo "Y=persist" > /tmp/src_$$; . /tmp/src_$$; echo $Y; rm /tmp/src_$$'
++
 +section "168. COMMAND AND TYPE"
++
 +compare_posix_output "command echo" 'command echo hello'
 +compare_posix_output "command builtin" 'command true; echo $?'
 +compare_posix_output "command v" 'command -v echo | grep -c echo'
 +compare_posix_output "type builtin" 'type echo 2>/dev/null | grep -c echo || echo 1'
 +compare_posix_output "type not found" 'type nonexistent_cmd_xyz 2>&1 | grep -c "not found" || echo 0'
++
 +section "169. GETOPTS VARIATIONS"
++
 +compare_posix_output "getopts simple" 'set -- -a; getopts a opt; echo $opt'
 +compare_posix_output "getopts arg" 'set -- -a val; getopts a: opt; echo $opt $OPTARG'
 +compare_posix_output "getopts multi" 'set -- -a -b; getopts ab opt && echo $opt'
 +compare_posix_output "getopts unknown" 'set -- -x; getopts a opt 2>/dev/null; echo ${opt:-?}'
 +compare_posix_output "getopts optind" 'set -- -a arg; getopts a opt; echo $OPTIND'
++
 +section "170. COLON AND TRUE/FALSE"
++
 +compare_posix_output "colon noop" ':; echo $?'
 +compare_posix_output "colon with args" ': arg1 arg2; echo $?'
 +compare_posix_output "true exit" 'true; echo $?'
 +compare_posix_output "false exit" 'false; echo $?'
 +compare_posix_output "colon in if" 'if :; then echo yes; fi'
 +compare_posix_output "colon in while" 'n=0; while :; do n=$((n+1)); [ $n -ge 3 ] && break; done; echo $n'
++
 +section "171. PWD AND CD"
++
 +compare_posix_output "pwd basic" 'pwd | grep -c "/"'
 +compare_posix_output "cd tmp" 'cd /tmp && pwd'
 +compare_posix_output "cd home" 'cd ~ && pwd | grep -c "/"'
 +compare_posix_output "cd dash" 'cd /tmp; cd /; cd -'
 +compare_posix_output "cd dotdot" 'cd /tmp; cd ..; pwd'
 +compare_posix_output "cd subshell" '(cd /tmp; pwd); pwd | grep -v "/tmp" | wc -l'
 +compare_posix_output "OLDPWD" 'cd /tmp; cd /; echo $OLDPWD'
++
 +section "172. UMASK VARIATIONS"
++
 +compare_posix_output "umask get" 'umask | grep -c "[0-7]"'
 +compare_posix_output "umask symbolic" 'umask -S | grep -c "u="'
++
 +section "173. TIMES BUILTIN"
++
 +compare_posix_output "times format" 'times 2>&1 | head -1 | grep -c "[0-9]" || echo 0'
++
 +section "174. HASH BUILTIN"
++
 +compare_posix_output "hash list" 'hash 2>/dev/null; echo $?'
 +compare_posix_output "hash r clear" 'hash -r 2>/dev/null; echo $?'
++
 +section "175. ALIAS VARIATIONS"
++
 +compare_posix_output "alias set" 'alias x=echo 2>/dev/null; echo ok'
 +compare_posix_output "alias list" 'alias 2>/dev/null; echo $?'
 +compare_posix_output "unalias" 'alias x=echo 2>/dev/null; unalias x 2>/dev/null; echo $?'
++
 +section "176. ADDITIONAL BUILTINS"
++
 +compare_posix_output "test bracket" '[ 1 -eq 1 ]; echo $?'
 +compare_posix_output "test not" '[ ! 1 -eq 2 ]; echo $?'
 +compare_posix_output "test and" '[ 1 -eq 1 ] && [ 2 -eq 2 ]; echo $?'
++
 +section "177. MORE CONTROL FLOW"
++
 +compare_posix_output "if compound" 'if [ 1 -eq 1 ] && [ 2 -eq 2 ]; then echo yes; fi'
 +compare_posix_output "while compound" 'n=2; while [ $n -gt 0 ] && true; do n=$((n-1)); done; echo $n'
++
 +section "178. ULIMIT VARIATIONS"
++
 +compare_posix_output "ulimit soft" 'ulimit -S -n 2>/dev/null | grep -c "[0-9]" || echo 1'
 +compare_posix_output "ulimit hard" 'ulimit -H -n 2>/dev/null | grep -c "[0-9]" || echo 1'
 +# Note: fortsh implements fewer limit types than bash - check both produce output
 +compare_posix_exit_code "ulimit all" 'test $(ulimit -a 2>/dev/null | wc -l) -ge 5'
++
 +section "179. SPECIAL EXPANSIONS"
++
 +compare_posix_output "length special" 'set -- a b c; echo ${#@}'
 +compare_posix_output "length star" 'set -- a b c; echo ${#*}'
 +compare_posix_output "at in quotes" 'set -- a b c; for x in "$@"; do echo $x; done | wc -l'
 +compare_posix_output "star in quotes" 'set -- a b c; echo "$*" | wc -w'
 +compare_posix_output "hash positional" 'set -- a b c d e; echo $#'
 +compare_posix_output "shift and hash" 'set -- a b c; shift; echo $#'
 +compare_posix_output "at unquoted" 'set -- a b c; for x in $@; do echo $x; done | wc -l'
 +compare_posix_output "star unquoted" 'set -- a b c; for x in $*; do echo $x; done | wc -l'
++
 +section "180. COMPLEX PATTERNS"
++
 +compare_posix_output "nested cmd sub" 'echo $(echo $(echo $(echo deep)))'
 +compare_posix_output "nested arith" 'echo $(( $(( $(( 1+1 )) + 1 )) + 1 ))'
 +compare_posix_output "mixed nesting" 'echo $(( $(echo 5) + $(echo 3) ))'
 +compare_posix_output "pipeline chain" 'echo test | cat | cat | cat | cat'
 +compare_posix_output "long and chain" 'true && true && true && true && echo yes'
 +compare_posix_output "long or chain" 'false || false || false || true && echo yes'
 +compare_posix_output "mixed logic" 'true && false || true && echo yes'
 +# Note: (((( ))) is arithmetic syntax. Compare exit codes.
 +compare_posix_exit_code "quad paren arithmetic" '((((echo deep))))'
 +compare_posix_output "nested brace" '{ { { echo deep; }; }; }'
 +compare_posix_output "func chain" 'f() { echo $1; }; g() { f hello; }; g'
++
 +section "181. WORD BOUNDARY CASES"
++
 +compare_posix_output "empty word" 'echo "" | cat'
 +compare_posix_output "space word" 'echo " " | cat'
 +compare_posix_output "tab word" 'echo "	" | cat'
 +compare_posix_output "newline word" 'echo "
 +" | wc -l'
 +compare_posix_output "mixed whitespace" 'echo " 	 " | cat'
 +compare_posix_output "leading space" 'echo " test" | cat'
 +compare_posix_output "trailing space" 'echo "test " | cat'
 +compare_posix_output "multiple spaces" 'echo "a    b" | cat'
++
 +section "182. NUMERIC EDGE CASES"
++
 +compare_posix_output "zero" 'echo $((0))'
 +compare_posix_output "negative one" 'echo $((-1))'
 +compare_posix_output "large number" 'echo $((999999))'
 +compare_posix_output "add negative" 'echo $((5 + -3))'
 +compare_posix_output "sub negative" 'echo $((5 - -3))'
 +compare_posix_output "mult negative" 'echo $((5 * -3))'
 +compare_posix_output "div negative" 'echo $((-15 / 3))'
 +compare_posix_output "mod negative" 'echo $((-7 % 3))'
 +compare_posix_output "compare negative" 'echo $((-1 < 0))'
 +compare_posix_output "zero compare" 'echo $((0 == 0))'
++
 +section "183. STRING BOUNDARY CASES"
++
 +compare_posix_output "empty length" 'x=""; echo ${#x}'
 +compare_posix_output "single char" 'x="a"; echo ${#x}'
 +compare_posix_output "special chars" 'x="!@#"; echo ${#x}'
 +compare_posix_output "spaces length" 'x="a b c"; echo ${#x}'
 +compare_posix_output "suffix on empty" 'x=""; echo ${x%.txt}'
 +compare_posix_output "prefix on empty" 'x=""; echo ${x#pre}'
 +compare_posix_output "default on set" 'x="val"; echo ${x:-def}'
 +compare_posix_output "alt on unset" 'unset x; echo ${x:+alt}'
 +compare_posix_output "alt on set" 'x="val"; echo ${x:+alt}'
 +compare_posix_output "assign on set" 'x="val"; echo ${x:=new}; echo $x'
++
 +section "184. GLOB BOUNDARY CASES"
++
 +compare_posix_output "star only" 'echo "*"'
 +compare_posix_output "question only" 'echo "?"'
 +compare_posix_output "bracket only" 'echo "[a]"'
 +compare_posix_output "glob in quotes" 'echo "*.txt"'
 +compare_posix_output "glob escaped" 'echo \*'
 +compare_posix_output "noglob star" 'set -f; echo *; set +f'
 +compare_posix_output "noglob question" 'set -f; echo ?; set +f'
 +compare_posix_output "noglob bracket" 'set -f; echo [a]; set +f'
++
 +section "185. REDIRECTION BOUNDARY CASES"
++
 +compare_posix_output "redir empty file" 'echo -n > /tmp/empty_$$; wc -c < /tmp/empty_$$; rm /tmp/empty_$$'
 +compare_posix_output "append to new" 'rm -f /tmp/new_$$; echo test >> /tmp/new_$$; cat /tmp/new_$$; rm /tmp/new_$$'
 +compare_posix_output "input from empty" 'echo -n > /tmp/empty_$$; cat < /tmp/empty_$$; echo done; rm /tmp/empty_$$'
 +compare_posix_output "stderr only" 'echo err >&2 2>&1 | cat'
 +compare_posix_output "stdout to null" 'echo test > /dev/null; echo $?'
 +compare_posix_output "stderr to null" 'echo err >&2 2>/dev/null; echo done'
++
 +section "186. PIPELINE BOUNDARY CASES"
++
 +compare_posix_output "empty input pipe" 'echo -n | cat'
 +compare_posix_output "single char pipe" 'echo a | cat'
 +compare_posix_output "large pipe" 'seq 1 100 | wc -l'
 +compare_posix_output "pipe to head 1" 'seq 1 10 | head -1'
 +compare_posix_output "pipe to tail 1" 'seq 1 10 | tail -1'
 +compare_posix_output "multi filter" 'seq 1 10 | head -5 | tail -1'
++
 +section "187. LOOP BOUNDARY CASES"
++
 +compare_posix_output "for single item" 'for i in x; do echo $i; done'
 +compare_posix_output "for no items" 'for i in; do echo $i; done; echo done'
 +compare_posix_output "while never" 'while false; do echo no; done; echo done'
 +compare_posix_output "until immediate" 'until true; do echo no; done; echo done'
 +compare_posix_output "break immediate" 'for i in 1 2 3; do break; echo $i; done; echo done'
 +compare_posix_output "continue all" 'for i in 1 2 3; do continue; echo $i; done; echo done'
 +compare_posix_output "nested break" 'for i in 1 2; do for j in a b; do break; done; echo $i; done'
 +compare_posix_output "break 2" 'for i in 1 2; do for j in a b; do break 2; done; done; echo done'
++
 +section "188. FUNCTION BOUNDARY CASES"
++
 +compare_posix_output "func no args" 'f() { echo ${1:-none}; }; f'
 +compare_posix_output "func many args" 'f() { echo $#; }; f a b c d e f g h i j'
 +compare_posix_output "func return max" 'f() { return 255; }; f; echo $?'
 +compare_posix_output "func return zero" 'f() { return 0; }; f; echo $?'
 +compare_posix_output "func empty" 'f() { :; }; f; echo $?'
 +compare_posix_output "func redefine" 'f() { echo one; }; f() { echo two; }; f'
 +compare_posix_output "func recursive depth" 'f() { [ $1 -eq 0 ] && echo done || f $(($1-1)); }; f 5'
++
 +section "189. CASE BOUNDARY CASES"
++
 +compare_posix_output "case empty string" 'case "" in "") echo empty;; esac'
 +compare_posix_output "case single char" 'case "x" in x) echo x;; esac'
 +compare_posix_output "case no patterns" 'case x in esac; echo done'
 +compare_posix_output "case all patterns" 'case x in a|b|c|x|y) echo match;; esac'
 +compare_posix_output "case star first" 'case x in *) echo star;; x) echo x;; esac'
 +compare_posix_output "case question" 'case ab in ??) echo two;; esac'
 +compare_posix_output "case bracket range" 'case m in [a-z]) echo lower;; esac'
 +compare_posix_output "case bracket neg" 'case 5 in [!a-z]) echo notlower;; esac'
++
 +section "190. SUBSHELL BOUNDARY CASES"
++
 +compare_posix_output "subshell empty" '(); echo $?'
 +compare_posix_output "subshell exit 0" '(exit 0); echo $?'
 +compare_posix_output "subshell exit 1" '(exit 1); echo $?'
 +compare_posix_output "subshell var" '(X=inner; echo $X)'
 +compare_posix_output "subshell no leak" 'X=outer; (X=inner); echo $X'
 +# Note: (( )) is arithmetic syntax. Compare exit codes.
 +compare_posix_exit_code "subshell nested arithmetic" '((echo deep))'
 +compare_posix_output "subshell pipe" '(echo test) | (cat)'
 +compare_posix_output "subshell output" '(echo sub; echo shell) | wc -l'
++
 +section "191. BRACE GROUP BOUNDARY CASES"
++
 +compare_posix_output "brace simple" '{ echo test; }'
 +compare_posix_output "brace multi" '{ echo a; echo b; }'
 +compare_posix_output "brace var" '{ X=val; }; echo $X'
 +compare_posix_output "brace exit" '{ exit 0; }; echo $?'
 +compare_posix_output "brace pipe" '{ echo test; } | cat'
 +compare_posix_output "brace nested" '{ { echo deep; }; }'
 +compare_posix_output "brace and sub" '{ (echo sub); echo brace; }'
 +compare_posix_output "brace redirect" '{ echo test; } > /tmp/br_$$; cat /tmp/br_$$; rm /tmp/br_$$'
++
 +section "192. COMMENT VARIATIONS"
++
 +compare_posix_output "comment end" 'echo test # comment'
 +compare_posix_output "comment only" '# just a comment
 +echo ok'
 +compare_posix_output "comment in quotes" 'echo "# not comment"'
 +compare_posix_output "hash in var" 'X="#value"; echo $X'
 +compare_posix_output "comment after semi" 'echo a; # comment
 +echo b'
++
 +section "193. LINE CONTINUATION"
++
 +compare_posix_output "backslash newline" 'echo hel\
 +lo'
 +compare_posix_output "continuation in cmd" 'ec\
 +ho test'
 +compare_posix_output "continuation in arg" 'echo "hel\
 +lo"'
 +compare_posix_output "multi continuation" 'echo a\
 +b\
 +c'
++
 +section "194. SEMICOLON VARIATIONS"
++
 +compare_posix_output "semi two cmds" 'echo a; echo b'
 +compare_posix_output "semi three cmds" 'echo a; echo b; echo c'
 +compare_posix_output "semi with space" 'echo a ; echo b'
 +compare_posix_output "semi end of line" 'echo test;'
 +compare_posix_output "semi in quotes" 'echo "a;b"'
 +compare_posix_output "semi empty" '; echo ok'
++
 +section "195. NEWLINE AS SEPARATOR"
++
 +compare_posix_output "newline sep" 'echo a
 +echo b'
 +compare_posix_output "newline in if" 'if true
 +then
 +echo yes
 +fi'
 +compare_posix_output "newline in for" 'for i in 1 2
 +do
 +echo $i
 +done | wc -l'
 +compare_posix_output "newline in case" 'case x in
 +x) echo yes;;
 +esac'
++
 +section "196. AMPERSAND VARIATIONS"
++
 +compare_posix_output "and simple" 'true && echo yes'
 +compare_posix_output "and fail" 'false && echo no; echo done'
 +compare_posix_output "and chain" 'true && true && echo yes'
 +compare_posix_output "and or mix" 'true && true || echo no'
 +compare_posix_output "or and mix" 'false || true && echo yes'
 +compare_posix_output "triple and" 'true && true && true && echo yes'
++
 +section "197. PIPE VARIATIONS"
++
 +compare_posix_output "or simple" 'false || echo yes'
 +compare_posix_output "or pass" 'true || echo no; echo done'
 +compare_posix_output "or chain" 'false || false || echo yes'
 +compare_posix_output "pipe simple" 'echo test | cat'
 +compare_posix_output "pipe chain" 'echo test | cat | cat'
 +compare_posix_output "mixed or and" 'false || true && echo yes'
++
 +section "198. PARENTHESES AND BRACES"
++
 +compare_posix_output "paren group" '(echo a; echo b)'
 +compare_posix_output "brace group" '{ echo a; echo b; }'
 +# Note: (( )) is arithmetic syntax. Compare exit codes.
 +compare_posix_exit_code "double paren arithmetic" '((echo deep))'
 +compare_posix_output "brace in brace" '{ { echo deep; }; }'
 +compare_posix_output "paren in brace" '{ (echo sub); }'
 +compare_posix_output "brace in paren" '({ echo brace; })'
++
 +section "199. RESERVED WORD POSITIONS"
++
 +compare_posix_output "if as arg" 'echo if'
 +compare_posix_output "then as arg" 'echo then'
 +compare_posix_output "else as arg" 'echo else'
 +compare_posix_output "fi as arg" 'echo fi'
 +compare_posix_output "for as arg" 'echo for'
 +compare_posix_output "while as arg" 'echo while'
 +compare_posix_output "case as arg" 'echo case'
 +compare_posix_output "do as arg" 'echo do'
 +compare_posix_output "done as arg" 'echo done'
++
 +section "200. ASSIGNMENT VARIATIONS"
++
 +compare_posix_output "simple assign" 'X=val; echo $X'
 +compare_posix_output "empty assign" 'X=; echo "[$X]"'
 +compare_posix_output "quoted assign" 'X="val"; echo $X'
 +compare_posix_output "single quote assign" "X='val'; echo \$X"
 +compare_posix_output "cmd sub assign" 'X=$(echo val); echo $X'
 +compare_posix_output "arith assign" 'X=$((1+1)); echo $X'
 +compare_posix_output "multi assign" 'X=1 Y=2; echo $X $Y'
 +compare_posix_output "prefix assign" 'X=val sh -c "echo \$X"'
 +compare_posix_output "no space assign" 'X=nospace; echo $X'
++
 +section "201. PARAMETER EXPANSION EDGE CASES"
++
 +compare_posix_output "unset default" 'echo ${UNSET_VAR_XYZ:-default}'
 +compare_posix_output "set default" 'X=val; echo ${X:-default}'
 +compare_posix_output "empty default" 'X=; echo ${X:-default}'
 +compare_posix_output "unset alt" 'echo ${UNSET_VAR_XYZ:+alt}'
 +compare_posix_output "set alt" 'X=val; echo ${X:+alt}'
 +compare_posix_output "empty alt" 'X=; echo ${X:+alt}'
 +compare_posix_output "unset assign" 'echo ${UNSET_VAR_ABC:=assigned}; echo $UNSET_VAR_ABC'
 +compare_posix_output "set no assign" 'X=val; echo ${X:=new}; echo $X'
 +compare_posix_output "length zero" 'X=; echo ${#X}'
 +compare_posix_output "length five" 'X=hello; echo ${#X}'
++
 +section "202. PATTERN MATCHING IN EXPANSION"
++
 +compare_posix_output "suffix percent" 'X=file.txt; echo ${X%.txt}'
 +compare_posix_output "suffix double" 'X=a.b.c; echo ${X%%.*}'
 +compare_posix_output "prefix hash" 'X=prefix_name; echo ${X#prefix_}'
 +compare_posix_output "prefix double" 'X=a.b.c; echo ${X##*.}'
 +compare_posix_output "no match suffix" 'X=file.txt; echo ${X%.jpg}'
 +compare_posix_output "no match prefix" 'X=file.txt; echo ${X#img_}'
 +compare_posix_output "star suffix" 'X=hello; echo ${X%l*}'
 +compare_posix_output "star prefix" 'X=hello; echo ${X#*l}'
 +compare_posix_output "question suffix" 'X=hello; echo ${X%?}'
 +compare_posix_output "question prefix" 'X=hello; echo ${X#?}'
++
 +section "203. ARITHMETIC OPERATORS"
++
 +compare_posix_output "arith add" 'echo $((5 + 3))'
 +compare_posix_output "arith sub" 'echo $((5 - 3))'
 +compare_posix_output "arith mul" 'echo $((5 * 3))'
 +compare_posix_output "arith div" 'echo $((15 / 3))'
 +compare_posix_output "arith mod" 'echo $((17 % 5))'
 +compare_posix_output "arith neg" 'echo $((-5))'
 +compare_posix_output "arith paren" 'echo $(((2 + 3) * 4))'
 +compare_posix_output "arith var" 'X=5; echo $((X + 1))'
 +compare_posix_output "arith nested" 'echo $(($((1+1)) + $((2+2))))'
 +compare_posix_output "arith zero div" 'echo $((0 / 1))'
++
 +section "204. ARITHMETIC COMPARISONS"
++
 +compare_posix_output "arith lt true" 'echo $((1 < 2))'
 +compare_posix_output "arith lt false" 'echo $((2 < 1))'
 +compare_posix_output "arith gt true" 'echo $((2 > 1))'
 +compare_posix_output "arith gt false" 'echo $((1 > 2))'
 +compare_posix_output "arith le true" 'echo $((1 <= 1))'
 +compare_posix_output "arith ge true" 'echo $((1 >= 1))'
 +compare_posix_output "arith eq true" 'echo $((5 == 5))'
 +compare_posix_output "arith eq false" 'echo $((5 == 6))'
 +compare_posix_output "arith ne true" 'echo $((5 != 6))'
 +compare_posix_output "arith ne false" 'echo $((5 != 5))'
++
 +section "205. ARITHMETIC LOGICAL"
++
 +compare_posix_output "arith and true" 'echo $((1 && 1))'
 +compare_posix_output "arith and false" 'echo $((1 && 0))'
 +compare_posix_output "arith or true" 'echo $((0 || 1))'
 +compare_posix_output "arith or false" 'echo $((0 || 0))'
 +compare_posix_output "arith not true" 'echo $((!0))'
 +compare_posix_output "arith not false" 'echo $((!1))'
 +compare_posix_output "arith ternary t" 'echo $((1 ? 10 : 20))'
 +compare_posix_output "arith ternary f" 'echo $((0 ? 10 : 20))'
 +compare_posix_output "arith complex" 'echo $(((1 && 1) || 0))'
 +compare_posix_output "arith nested log" 'echo $((!(0 || 0)))'
++
 +section "206. TEST NUMERIC OPERATORS"
++
 +compare_posix_output "test eq true" '[ 5 -eq 5 ]; echo $?'
 +compare_posix_output "test eq false" '[ 5 -eq 6 ]; echo $?'
 +compare_posix_output "test ne true" '[ 5 -ne 6 ]; echo $?'
 +compare_posix_output "test ne false" '[ 5 -ne 5 ]; echo $?'
 +compare_posix_output "test lt true" '[ 3 -lt 5 ]; echo $?'
 +compare_posix_output "test lt false" '[ 5 -lt 3 ]; echo $?'
 +compare_posix_output "test le true" '[ 5 -le 5 ]; echo $?'
 +compare_posix_output "test gt true" '[ 5 -gt 3 ]; echo $?'
 +compare_posix_output "test ge true" '[ 5 -ge 5 ]; echo $?'
 +compare_posix_output "test zero" '[ 0 -eq 0 ]; echo $?'
++
 +section "207. TEST STRING OPERATORS"
++
 +compare_posix_output "test str eq true" '[ "abc" = "abc" ]; echo $?'
 +compare_posix_output "test str eq false" '[ "abc" = "def" ]; echo $?'
 +compare_posix_output "test str ne true" '[ "abc" != "def" ]; echo $?'
 +compare_posix_output "test str ne false" '[ "abc" != "abc" ]; echo $?'
 +compare_posix_output "test z true" '[ -z "" ]; echo $?'
 +compare_posix_output "test z false" '[ -z "x" ]; echo $?'
 +compare_posix_output "test n true" '[ -n "x" ]; echo $?'
 +compare_posix_output "test n false" '[ -n "" ]; echo $?'
 +compare_posix_output "test str space" '[ "a b" = "a b" ]; echo $?'
 +compare_posix_output "test str empty" '[ "" = "" ]; echo $?'
++
 +section "208. TEST FILE OPERATORS"
++
 +compare_posix_output "test e exist" '[ -e /tmp ]; echo $?'
 +compare_posix_output "test e noexist" '[ -e /nonexistent_xyz ]; echo $?'
 +compare_posix_output "test f file" '[ -f /etc/passwd ]; echo $?'
 +compare_posix_output "test f dir" '[ -f /tmp ]; echo $?'
 +compare_posix_output "test d dir" '[ -d /tmp ]; echo $?'
 +compare_posix_output "test d file" '[ -d /etc/passwd ]; echo $?'
 +compare_posix_output "test r read" '[ -r /etc/passwd ]; echo $?'
 +compare_posix_output "test w write" '[ -w /tmp ]; echo $?'
 +compare_posix_output "test x exec" '[ -x /bin/sh ]; echo $?'
 +compare_posix_output "test s size" '[ -s /etc/passwd ]; echo $?'
++
 +section "209. TEST LOGICAL OPERATORS"
++
 +compare_posix_output "test not true" '[ ! -f /nonexistent ]; echo $?'
 +compare_posix_output "test not false" '[ ! -d /tmp ]; echo $?'
 +compare_posix_output "test and true" '[ -d /tmp ] && [ -f /etc/passwd ]; echo $?'
 +compare_posix_output "test and false" '[ -d /tmp ] && [ -f /nonexistent ]; echo $?'
 +compare_posix_output "test or true" '[ -f /nonexistent ] || [ -d /tmp ]; echo $?'
 +compare_posix_output "test or false" '[ -f /nonexistent ] || [ -d /nonexistent ]; echo $?'
 +compare_posix_output "test complex" '[ -d /tmp ] && [ ! -f /nonexistent ]; echo $?'
 +compare_posix_output "test chain" '[ 1 -eq 1 ] && [ 2 -eq 2 ] && [ 3 -eq 3 ]; echo $?'
++
 +section "210. HEREDOC VARIATIONS"
++
 +compare_posix_output "heredoc simple" 'cat <<EOF
 +line
 +EOF'
 +compare_posix_output "heredoc multi" 'cat <<EOF
 +one
 +two
 +three
 +EOF'
 +compare_posix_output "heredoc empty" 'cat <<EOF
 +EOF
 +echo done'
 +compare_posix_output "heredoc expand" 'X=val; cat <<EOF
 +$X
 +EOF'
 +compare_posix_output "heredoc no expand" "cat <<'EOF'
 +\$X
 +EOF"
 +compare_posix_output "heredoc indent" 'cat <<-EOF
 +	tab
 +EOF'
 +compare_posix_output "heredoc special" 'cat <<EOF
 +* $ @ !
 +EOF'
++
 +section "211. IFS WORD SPLITTING"
++
 +compare_posix_output "ifs split colon" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "ifs split space" 'IFS=" "; x="a b c"; set -- $x; echo $#'
 +compare_posix_output "ifs split multi" 'IFS=":;"; x="a:b;c"; set -- $x; echo $#'
 +compare_posix_output "ifs default split" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "ifs empty no split" 'IFS=""; x="a b"; set -- $x; echo $#'
 +compare_posix_output "ifs unset default" 'unset IFS; x="a  b"; set -- $x; echo $#'
 +compare_posix_output "ifs in for" 'IFS=:; for i in a:b:c; do echo $i; done'
 +compare_posix_output "ifs restore" 'OLD="$IFS"; IFS=:; IFS="$OLD"; echo ok'
++
 +section "212. WORD SPLITTING"
++
 +compare_posix_output "split unquoted" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "split quoted" 'x="a b c"; set -- "$x"; echo $#'
 +compare_posix_output "split ifs" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "split empty" 'x=""; set -- $x; echo $#'
 +compare_posix_output "split whitespace" 'x="  a  b  "; set -- $x; echo $#'
 +compare_posix_output "split preserve" 'x="a  b"; echo "$x"'
 +compare_posix_output "split multiple" 'x="a b" y="c d"; set -- $x $y; echo $#'
++
 +section "213. PATHNAME EXPANSION"
++
 +compare_posix_output "glob star" 'set -f; echo *; set +f'
 +compare_posix_output "glob question" 'set -f; echo ?; set +f'
 +compare_posix_output "glob bracket" 'set -f; echo [abc]; set +f'
 +compare_posix_output "glob quoted" 'echo "*"'
 +compare_posix_output "glob escaped" 'echo \*'
 +compare_posix_output "glob noglob" 'set -f; echo *.txt; set +f'
 +compare_posix_output "glob in var" 'x="*"; echo "$x"'
++
 +section "214. TILDE EXPANSION"
++
 +compare_posix_output "tilde alone" 'echo ~ | grep -c "/"'
 +compare_posix_output "tilde slash" 'echo ~/ | grep -c "/"'
 +compare_posix_output "tilde quoted" 'echo "~"'
 +compare_posix_output "tilde in var" 'x=~; echo $x | grep -c "/"'
 +compare_posix_output "tilde assign" 'HOME=/tmp; echo ~ | grep -c "/"'
++
 +section "215. COMMAND SUBSTITUTION NESTING"
++
 +compare_posix_output "cmd sub simple" 'echo $(echo hello)'
 +compare_posix_output "cmd sub nested" 'echo $(echo $(echo deep))'
 +compare_posix_output "cmd sub triple" 'echo $(echo $(echo $(echo triple)))'
 +compare_posix_output "cmd sub arith" 'echo $(echo $((1+1)))'
 +compare_posix_output "cmd sub var" 'X=val; echo $(echo $X)'
 +compare_posix_output "cmd sub quote" 'echo "$(echo "quoted")"'
 +compare_posix_output "backtick simple" 'echo `echo hello`'
 +compare_posix_output "backtick nested" 'echo `echo \`echo deep\``'
++
 +section "216. PIPELINE ALTERNATIVES"
++
 +compare_posix_output "pipe chain filter" 'echo test | grep test | cat'
 +compare_posix_output "subshell pipe" '(echo test) | cat'
 +compare_posix_output "brace pipe" '{ echo test; } | cat'
 +compare_posix_output "pipe to head" 'printf "a\nb\nc\n" | head -2 | wc -l'
++
 +section "217. EXIT STATUS"
++
 +compare_posix_output "exit 0" 'exit 0'
 +compare_posix_output "exit 1" '(exit 1); echo $?'
 +compare_posix_output "exit 255" '(exit 255); echo $?'
 +compare_posix_output "true status" 'true; echo $?'
 +compare_posix_output "false status" 'false; echo $?'
 +compare_posix_output "cmd not found" 'nonexistent_cmd_xyz 2>/dev/null; echo $?'
 +compare_posix_output "pipe status" 'false | true; echo $?'
 +compare_posix_output "and status" 'true && true; echo $?'
 +compare_posix_output "or status" 'false || true; echo $?'
 +compare_posix_output "not status" '! false; echo $?'
++
 +section "218. SIGNAL HANDLING"
++
 +# Note: trap output may vary by environment - test exit code
 +compare_posix_exit_code "trap list" 'trap >/dev/null 2>&1'
 +compare_posix_output "trap set" 'trap "echo caught" INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap reset" 'trap "echo x" INT; trap - INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap ignore" 'trap "" INT; trap | grep -c INT || echo 0'
 +compare_posix_output "kill signal" 'kill -l | head -1 | grep -c "[A-Z]" || echo 1'
++
 +section "219. ADDITIONAL TESTS"
++
 +compare_posix_output "pipeline exit" 'true | false; echo $?'
 +compare_posix_output "pipeline true" 'true | true; echo $?'
 +compare_posix_output "negation pipe" '! false | true; echo $?'
 +compare_posix_output "subshell exit" '(exit 42); echo $?'
 +compare_posix_output "brace exit" '{ true; }; echo $?'
++
 +section "220. ENVIRONMENT VARIABLES"
++
 +compare_posix_output "env home" 'echo ${HOME:-unset} | grep -c "/"'
 +compare_posix_output "env path" 'echo ${PATH:-unset} | grep -c ":"'
 +compare_posix_output "env pwd" 'echo ${PWD:-unset} | grep -c "/"'
 +compare_posix_output "env shell" 'echo ${SHELL:-unset} | grep -c "/" || echo 1'
 +compare_posix_output "export var" 'export X=val; sh -c "echo \$X"'
 +compare_posix_output "prefix assign" 'X=val sh -c "echo \$X"'
 +compare_posix_output "unset env" 'export X=val; unset X; echo ${X:-unset}'
++
 +section "221. SPECIAL VARIABLES"
++
 +compare_posix_output "dollar zero" 'echo ${0:-shell} | grep -c "."'
 +compare_posix_output "dollar hash" 'set -- a b c; echo $#'
 +compare_posix_output "dollar question" 'true; echo $?'
 +compare_posix_output "dollar dollar" 'echo $$ | grep -c "[0-9]"'
 +compare_posix_output "dollar underscore" 'echo test; echo ${_:-none}'
 +compare_posix_output "dollar at" 'set -- a b c; echo "$@"'
 +compare_posix_output "dollar star" 'set -- a b c; echo "$*"'
 +compare_posix_output "dollar minus" 'echo $- | grep -c "."'
++
 +section "222. POSITIONAL PARAMETERS"
++
 +compare_posix_output "pos one" 'set -- a b c; echo $1'
 +compare_posix_output "pos two" 'set -- a b c; echo $2'
 +compare_posix_output "pos three" 'set -- a b c; echo $3'
 +compare_posix_output "pos shift" 'set -- a b c; shift; echo $1'
 +compare_posix_output "pos shift n" 'set -- a b c d e; shift 3; echo $1'
 +compare_posix_output "pos set" 'set -- x y z; echo $1 $2 $3'
 +compare_posix_output "pos clear" 'set -- a b c; set --; echo ${1:-empty}'
 +compare_posix_output "pos count" 'set -- a b c d e; echo $#'
 +compare_posix_output "pos all at" 'set -- a b c; for x in "$@"; do echo $x; done | wc -l'
 +compare_posix_output "pos all star" 'set -- a b c; echo "$*" | wc -w'
++
 +section "223. FUNCTION DEFINITION STYLES"
++
 +compare_posix_output "func keyword" 'f() { echo hello; }; f'
 +compare_posix_output "func oneline" 'f() { echo one; }; f'
 +compare_posix_output "func multiline" 'f() {
 +echo multi
 +}; f'
 +compare_posix_output "func with args" 'f() { echo $1 $2; }; f a b'
 +compare_posix_output "func return" 'f() { return 5; }; f; echo $?'
 +compare_posix_output "func local var" 'X=outer; f() { X=inner; }; f; echo $X'
 +compare_posix_output "func recursive" 'f() { [ $1 -eq 0 ] && echo done || f $(($1-1)); }; f 3'
++
 +section "224. FUNCTION SCOPE"
++
 +compare_posix_output "func global var" 'X=global; f() { echo $X; }; f'
 +compare_posix_output "func modify var" 'X=old; f() { X=new; }; f; echo $X'
 +compare_posix_output "func args" 'f() { echo $#; }; f a b c'
 +compare_posix_output "func positional" 'f() { echo $1; }; set -- x; f a; echo $1'
 +compare_posix_output "func in subshell" 'f() { echo func; }; (f)'
 +compare_posix_output "func in pipeline" 'f() { echo test; }; f | cat'
 +compare_posix_output "func redefine" 'f() { echo one; }; f; f() { echo two; }; f'
++
 +section "225. ALIAS BASICS"
++
 +compare_posix_output "alias define" 'alias x=echo 2>/dev/null; echo ok'
 +compare_posix_output "alias list" 'alias 2>/dev/null; echo $?'
 +compare_posix_output "unalias" 'alias x=echo 2>/dev/null; unalias x 2>/dev/null; echo $?'
 +compare_posix_output "unalias all" 'unalias -a 2>/dev/null; echo $?'
++
 +section "226. CONTROL STRUCTURES COMPREHENSIVE"
++
 +compare_posix_output "if basic" 'if true; then echo yes; fi'
 +compare_posix_output "if else" 'if false; then echo no; else echo yes; fi'
 +compare_posix_output "if elif" 'if false; then echo 1; elif true; then echo 2; fi'
 +compare_posix_output "if nested" 'if true; then if true; then echo deep; fi; fi'
 +compare_posix_output "for basic" 'for i in 1 2 3; do echo $i; done | wc -l'
 +compare_posix_output "for empty" 'for i in; do echo $i; done; echo done'
 +compare_posix_output "while basic" 'n=3; while [ $n -gt 0 ]; do echo $n; n=$((n-1)); done | wc -l'
 +compare_posix_output "until basic" 'n=0; until [ $n -eq 3 ]; do n=$((n+1)); done; echo $n'
 +compare_posix_output "case basic" 'case x in x) echo yes;; esac'
 +compare_posix_output "case default" 'case x in y) echo no;; *) echo default;; esac'
++
 +section "227. BREAK AND CONTINUE"
++
 +compare_posix_output "break simple" 'for i in 1 2 3; do [ $i -eq 2 ] && break; echo $i; done'
 +compare_posix_output "continue simple" 'for i in 1 2 3; do [ $i -eq 2 ] && continue; echo $i; done'
 +compare_posix_output "break nested" 'for i in 1 2; do for j in a b; do break; done; echo $i; done'
 +compare_posix_output "break 2" 'for i in 1 2; do for j in a b; do break 2; done; done; echo done'
 +compare_posix_output "continue nested" 'for i in 1 2; do for j in a b; do continue 2; done; echo no; done; echo done'
++
 +section "228. RETURN AND EXIT"
++
 +compare_posix_output "return 0" 'f() { return 0; }; f; echo $?'
 +compare_posix_output "return 1" 'f() { return 1; }; f; echo $?'
 +compare_posix_output "return 255" 'f() { return 255; }; f; echo $?'
 +compare_posix_output "exit subshell" '(exit 5); echo $?'
 +compare_posix_output "exit brace" '{ exit 0; }; echo unreached'
 +compare_posix_output "return implicit" 'f() { true; }; f; echo $?'
++
 +section "229. COMPOUND COMMANDS"
++
 +compare_posix_output "paren list" '(echo a; echo b) | wc -l'
 +compare_posix_output "brace list" '{ echo a; echo b; } | wc -l'
 +compare_posix_output "if in paren" '(if true; then echo yes; fi)'
 +compare_posix_output "for in brace" '{ for i in 1 2; do echo $i; done; } | wc -l'
 +compare_posix_output "while in paren" '(n=2; while [ $n -gt 0 ]; do echo $n; n=$((n-1)); done) | wc -l'
 +compare_posix_output "case in brace" '{ case x in x) echo yes;; esac; }'
 +compare_posix_output "func in paren" '(f() { echo func; }; f)'
++
 +section "230. COMPLEX COMMAND COMBINATIONS"
++
 +compare_posix_output "for pipe filter" 'for i in 1 2 3 4 5; do echo $i; done | head -3 | wc -l'
 +compare_posix_output "case in for" 'for x in a b c; do case $x in a) echo first;; esac; done'
 +compare_posix_output "if in while" 'n=2; while [ $n -gt 0 ]; do if [ $n -eq 1 ]; then echo one; fi; n=$((n-1)); done'
 +compare_posix_output "nested for" 'for i in 1 2; do for j in a b; do echo $i$j; done; done | wc -l'
 +compare_posix_output "subshell in for" 'for i in 1 2; do (echo $i); done | wc -l'
 +compare_posix_output "func in for" 'f() { echo $1; }; for i in a b c; do f $i; done | wc -l'
 +compare_posix_output "pipe to sort" 'printf "c\na\nb\n" | sort | head -1'
 +# Note: (( )) is arithmetic syntax. Compare exit codes.
 +compare_posix_exit_code "nested subshell arithmetic" '((echo deep))'
++
 +section "231. EXPR COMMAND"
++
 +compare_posix_output "expr add" 'expr 5 + 3'
 +compare_posix_output "expr sub" 'expr 10 - 3'
 +compare_posix_output "expr mul" 'expr 4 \* 5'
 +compare_posix_output "expr div" 'expr 20 / 4'
 +compare_posix_output "expr mod" 'expr 17 % 5'
 +compare_posix_output "expr compare lt" 'expr 3 \< 5'
 +compare_posix_output "expr compare gt" 'expr 5 \> 3'
 +compare_posix_output "expr compare eq" 'expr 5 = 5'
 +compare_posix_output "expr string" 'expr length hello'
 +compare_posix_output "expr substr" 'expr substr hello 2 3'
++
 +section "232. BASENAME AND DIRNAME"
++
 +compare_posix_output "basename simple" 'basename /path/to/file'
 +compare_posix_output "basename suffix" 'basename /path/to/file.txt .txt'
 +compare_posix_output "basename no path" 'basename file.txt'
 +compare_posix_output "dirname simple" 'dirname /path/to/file'
 +compare_posix_output "dirname root" 'dirname /file'
 +compare_posix_output "dirname relative" 'dirname file'
 +compare_posix_output "dirname dot" 'dirname ./file'
 +compare_posix_output "dirname trailing" 'dirname /path/to/'
++
 +section "233. CUT COMMAND"
++
 +compare_posix_output "cut field" 'echo "a:b:c" | cut -d: -f2'
 +compare_posix_output "cut fields" 'echo "a:b:c" | cut -d: -f1,3'
 +compare_posix_output "cut chars" 'echo "hello" | cut -c1-3'
 +compare_posix_output "cut char single" 'echo "hello" | cut -c2'
 +compare_posix_output "cut range" 'echo "a:b:c:d" | cut -d: -f2-3'
++
 +section "234. TR COMMAND"
++
 +compare_posix_output "tr simple" 'echo abc | tr a-z A-Z'
 +compare_posix_output "tr delete" 'echo "a1b2c3" | tr -d 0-9'
 +compare_posix_output "tr squeeze" 'echo "aabbcc" | tr -s a-z'
 +compare_posix_output "tr single" 'echo abc | tr a x'
 +compare_posix_output "tr complement" 'echo "a1b2" | tr -cd a-z'
++
 +section "235. SORT COMMAND"
++
 +compare_posix_output "sort lines" 'printf "c\na\nb\n" | sort'
 +compare_posix_output "sort reverse" 'printf "a\nb\nc\n" | sort -r'
 +compare_posix_output "sort numeric" 'printf "10\n2\n1\n" | sort -n'
 +compare_posix_output "sort unique" 'printf "a\na\nb\n" | sort -u'
 +compare_posix_output "sort first" 'printf "c\na\nb\n" | sort | head -1'
++
 +section "236. UNIQ COMMAND"
++
 +compare_posix_output "uniq simple" 'printf "a\na\nb\n" | uniq'
 +compare_posix_output "uniq count" 'printf "a\na\nb\n" | uniq -c | wc -l'
 +compare_posix_output "uniq duplicate" 'printf "a\na\nb\n" | uniq -d'
 +compare_posix_output "uniq unique" 'printf "a\na\nb\n" | uniq -u'
++
 +section "237. WC COMMAND"
++
 +compare_posix_output "wc lines" 'printf "a\nb\nc\n" | wc -l'
 +compare_posix_output "wc words" 'echo "one two three" | wc -w'
 +compare_posix_output "wc chars" 'echo "hello" | wc -c'
 +compare_posix_output "wc empty" 'echo "" | wc -l'
++
 +section "238. HEAD AND TAIL"
++
 +compare_posix_output "head default" 'seq 1 20 | head | wc -l'
 +compare_posix_output "head n" 'seq 1 10 | head -3'
 +compare_posix_output "tail default" 'seq 1 20 | tail | wc -l'
 +compare_posix_output "tail n" 'seq 1 10 | tail -3'
 +compare_posix_output "head tail combo" 'seq 1 10 | head -5 | tail -1'
++
 +section "239. GREP PATTERNS"
++
 +compare_posix_output "grep simple" 'echo hello | grep hello'
 +compare_posix_output "grep no match" 'echo hello | grep xyz; echo $?'
 +compare_posix_output "grep count" 'printf "a\nb\na\n" | grep -c a'
 +compare_posix_output "grep ignore case" 'echo HELLO | grep -i hello'
 +compare_posix_output "grep invert" 'printf "a\nb\n" | grep -v a'
 +compare_posix_output "grep line" 'printf "abc\ndef\n" | grep -n abc'
++
 +section "240. SED BASICS"
++
 +compare_posix_output "sed substitute" 'echo hello | sed "s/hello/world/"'
 +compare_posix_output "sed global" 'echo "aaa" | sed "s/a/b/g"'
 +compare_posix_output "sed delete" 'printf "a\nb\nc\n" | sed "1d" | wc -l'
 +compare_posix_output "sed print" 'printf "a\nb\n" | sed -n "1p"'
 +compare_posix_output "sed range" 'printf "a\nb\nc\n" | sed "1,2d"'
++
 +section "241. AWK BASICS"
++
 +compare_posix_output "awk print" 'echo "a b c" | awk "{print \$2}"'
 +compare_posix_output "awk field" 'echo "a:b:c" | awk -F: "{print \$2}"'
 +compare_posix_output "awk NF" 'echo "a b c" | awk "{print NF}"'
 +compare_posix_output "awk NR" 'printf "a\nb\n" | awk "{print NR}"'
 +compare_posix_output "awk math" 'echo "5 3" | awk "{print \$1 + \$2}"'
++
 +section "242. TEE COMMAND"
++
 +compare_posix_output "tee output" 'echo test | tee /dev/null'
 +compare_posix_output "tee passthrough" 'echo hello | tee /dev/null | cat'
++
 +section "243. XARGS BASICS"
++
 +compare_posix_output "xargs echo" 'echo "a b c" | xargs echo'
 +compare_posix_output "xargs n1" 'printf "a\nb\nc\n" | xargs -n1 echo | wc -l'
++
 +section "244. FIND BASICS"
++
 +compare_posix_output "find type d" 'find /tmp -maxdepth 1 -type d 2>/dev/null | head -1 | grep -c "/"'
 +compare_posix_output "find name" 'find /etc -maxdepth 1 -name "passwd" 2>/dev/null | grep -c passwd || echo 0'
++
 +section "245. TEST COMMAND FORMS"
++
 +compare_posix_output "test bracket" '[ 1 -eq 1 ]; echo $?'
 +compare_posix_output "test keyword" 'test 1 -eq 1; echo $?'
 +compare_posix_output "test string" '[ "a" = "a" ]; echo $?'
 +compare_posix_output "test empty" '[ -z "" ]; echo $?'
 +compare_posix_output "test nonempty" '[ -n "x" ]; echo $?'
 +compare_posix_output "test not" '[ ! 1 -eq 2 ]; echo $?'
 +compare_posix_output "test and ext" '[ 1 -eq 1 -a 2 -eq 2 ]; echo $?'
 +compare_posix_output "test or ext" '[ 1 -eq 2 -o 2 -eq 2 ]; echo $?'
++
 +section "246. ARITHMETIC BITWISE"
++
 +compare_posix_output "arith and" 'echo $((5 & 3))'
 +compare_posix_output "arith or" 'echo $((5 | 3))'
 +compare_posix_output "arith xor" 'echo $((5 ^ 3))'
 +compare_posix_output "arith not" 'echo $((~0))'
 +compare_posix_output "arith lshift" 'echo $((1 << 4))'
 +compare_posix_output "arith rshift" 'echo $((16 >> 2))'
++
 +section "247. COMPLEX CASE PATTERNS"
++
 +compare_posix_output "case or pattern" 'case abc in a*|b*) echo match;; esac'
 +compare_posix_output "case bracket" 'case a in [abc]) echo match;; esac'
 +compare_posix_output "case negbracket" 'case d in [!abc]) echo match;; esac'
 +compare_posix_output "case question" 'case ab in ??) echo two;; esac'
 +compare_posix_output "case star" 'case anything in *) echo match;; esac'
 +compare_posix_output "case empty" 'case "" in "") echo empty;; esac'
 +compare_posix_output "case number" 'case 42 in [0-9]*) echo num;; esac'
++
 +section "248. COMPLEX FOR LOOPS"
++
 +compare_posix_output "for glob safe" 'set -f; for i in *; do echo "$i"; done; set +f'
 +compare_posix_output "for break early" 'for i in 1 2 3 4 5; do echo $i; [ $i -eq 3 ] && break; done | wc -l'
 +compare_posix_output "for continue skip" 'for i in 1 2 3; do [ $i -eq 2 ] && continue; echo $i; done | wc -l'
 +compare_posix_output "for nested count" 'for i in 1 2; do for j in a b c; do echo x; done; done | wc -l'
 +compare_posix_output "for empty list" 'for i in; do echo never; done; echo done'
 +compare_posix_output "for single" 'for i in only; do echo $i; done'
++
 +section "249. COMPLEX WHILE LOOPS"
++
 +compare_posix_output "while decrement" 'n=5; while [ $n -gt 0 ]; do n=$((n-1)); done; echo $n'
 +compare_posix_output "while false" 'while false; do echo never; done; echo done'
 +compare_posix_output "while break" 'n=0; while true; do n=$((n+1)); [ $n -ge 3 ] && break; done; echo $n'
 +compare_posix_output "while nested" 'i=2; while [ $i -gt 0 ]; do j=2; while [ $j -gt 0 ]; do echo x; j=$((j-1)); done; i=$((i-1)); done | wc -l'
 +compare_posix_output "until true" 'until true; do echo never; done; echo done'
 +compare_posix_output "until count" 'n=0; until [ $n -ge 3 ]; do n=$((n+1)); done; echo $n'
++
 +section "250. COMPLEX FUNCTIONS"
++
 +compare_posix_output "func args count" 'f() { echo $#; }; f a b c d e'
 +compare_posix_output "func all args" 'f() { echo "$@"; }; f a b c'
 +compare_posix_output "func star args" 'f() { echo "$*"; }; f a b c'
 +compare_posix_output "func return val" 'f() { return 42; }; f; echo $?'
 +compare_posix_output "func modify global" 'x=old; f() { x=new; }; f; echo $x'
 +compare_posix_output "func recursive" 'f() { [ $1 -le 1 ] && echo 1 || echo $(($(f $(($1-1))) + $(f $(($1-2))))); }; f 5'
 +compare_posix_output "func in subshell" 'f() { echo inner; }; (f)'
 +compare_posix_output "func pipe" 'f() { echo test; }; f | cat'
 +compare_posix_output "func empty" 'f() { :; }; f; echo $?'
 +compare_posix_output "func chain" 'f() { echo $1; }; g() { f hello; }; g'
++
 +section "251. SHELL ARITHMETIC EDGE CASES"
++
 +compare_posix_output "arith octal" 'echo $((010))'
 +compare_posix_output "arith hex" 'echo $((0x10))'
 +compare_posix_output "arith unary plus" 'echo $((+5))'
 +compare_posix_output "arith unary minus" 'echo $((-5))'
 +compare_posix_output "arith double neg" 'echo $((--5))'
 +compare_posix_output "arith complex" 'echo $(((1+2)*(3+4)))'
 +compare_posix_output "arith assign" 'x=5; echo $((x=x+1)); echo $x'
 +compare_posix_output "arith incr" 'x=5; echo $((x+=1))'
 +compare_posix_output "arith decr" 'x=5; echo $((x-=1))'
++
 +section "252. VARIABLE EDGE CASES"
++
 +compare_posix_output "var underscore" '_x=val; echo $_x'
 +compare_posix_output "var number suffix" 'x1=val; echo $x1'
 +compare_posix_output "var long name" 'very_long_variable_name_here=val; echo $very_long_variable_name_here'
 +compare_posix_output "var empty val" 'x=; echo "[$x]"'
 +compare_posix_output "var space val" 'x="a b"; echo "$x"'
 +compare_posix_output "var newline val" 'x="a
 +b"; echo "$x" | wc -l'
 +compare_posix_output "var special chars" 'x="!@#"; echo "$x"'
 +compare_posix_output "var equals in val" 'x="a=b"; echo "$x"'
++
 +section "253. QUOTING EDGE CASES"
++
 +compare_posix_output "quote empty" 'echo ""'
 +compare_posix_output "quote space" 'echo " "'
 +compare_posix_output "quote tab" 'echo "	"'
 +compare_posix_output "quote newline" 'echo "
 +"'
 +compare_posix_output "quote dollar" 'echo "\$"'
 +compare_posix_output "quote backslash" 'echo "\\"'
 +compare_posix_output "quote backtick" 'echo "\`"'
 +compare_posix_output "quote double" 'echo "\""'
 +compare_posix_output "single in double" 'echo "'"'"'"'
 +compare_posix_output "double in single" "echo '\"'"
++
 +section "254. PARAMETER EXPANSION COMPREHENSIVE"
++
 +compare_posix_output "param default unset" 'echo ${undef:-default}'
 +compare_posix_output "param default empty" 'x=; echo ${x:-default}'
 +compare_posix_output "param default set" 'x=val; echo ${x:-default}'
 +compare_posix_output "param alt unset" 'echo ${undef:+alt}'
 +compare_posix_output "param alt empty" 'x=; echo ${x:+alt}'
 +compare_posix_output "param alt set" 'x=val; echo ${x:+alt}'
 +compare_posix_output "param assign unset" 'unset y; echo ${y:=assigned}; echo $y'
 +compare_posix_output "param length" 'x=hello; echo ${#x}'
 +compare_posix_output "param suffix" 'x=file.txt; echo ${x%.txt}'
 +compare_posix_output "param prefix" 'x=prefix_name; echo ${x#prefix_}'
++
 +section "255. REDIRECTION COMPREHENSIVE"
++
 +compare_posix_output "redir stdout" 'echo test > /tmp/r$$; cat /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir append" 'echo a > /tmp/r$$; echo b >> /tmp/r$$; cat /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir stdin" 'echo test > /tmp/r$$; cat < /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir stderr" 'echo err >&2 2>/dev/null; echo ok'
 +compare_posix_output "redir fd dup" 'echo test 2>&1 | cat'
 +compare_posix_output "redir devnull" 'echo test > /dev/null; echo $?'
 +compare_posix_output "redir clobber" 'echo a > /tmp/r$$; echo b > /tmp/r$$; cat /tmp/r$$; rm /tmp/r$$'
++
 +section "256. HEREDOC COMPREHENSIVE"
++
 +compare_posix_output "heredoc basic" 'cat <<EOF
 +line
 +EOF'
 +compare_posix_output "heredoc multi" 'cat <<EOF
 +one
 +two
 +EOF'
 +compare_posix_output "heredoc var" 'x=val; cat <<EOF
 +$x
 +EOF'
 +compare_posix_output "heredoc quoted" "cat <<'EOF'
 +\$x
 +EOF"
 +compare_posix_output "heredoc tab strip" 'cat <<-EOF
 +	indented
 +EOF'
++
 +section "257. PIPELINE COMPREHENSIVE"
++
 +compare_posix_output "pipe two" 'echo test | cat'
 +compare_posix_output "pipe three" 'echo test | cat | cat'
 +compare_posix_output "pipe four" 'echo test | cat | cat | cat'
 +compare_posix_output "pipe filter" 'echo hello | grep h'
 +compare_posix_output "pipe transform" 'echo abc | tr a-z A-Z'
 +compare_posix_output "pipe count" 'printf "a\nb\nc\n" | wc -l'
 +compare_posix_output "pipe subshell" '(echo test) | cat'
 +compare_posix_output "pipe brace" '{ echo test; } | cat'
++
 +section "258. LOGICAL OPERATORS COMPREHENSIVE"
++
 +compare_posix_output "and tt" 'true && true; echo $?'
 +compare_posix_output "and tf" 'true && false; echo $?'
 +compare_posix_output "and ft" 'false && true; echo $?'
 +compare_posix_output "and ff" 'false && false; echo $?'
 +compare_posix_output "or tt" 'true || true; echo $?'
 +compare_posix_output "or tf" 'true || false; echo $?'
 +compare_posix_output "or ft" 'false || true; echo $?'
 +compare_posix_output "or ff" 'false || false; echo $?'
 +compare_posix_output "not t" '! true; echo $?'
 +compare_posix_output "not f" '! false; echo $?'
 +compare_posix_output "mixed 1" 'true && false || echo fallback'
 +compare_posix_output "mixed 2" 'false || true && echo success'
++
 +section "259. SUBSHELL COMPREHENSIVE"
++
 +compare_posix_output "sub echo" '(echo sub)'
 +compare_posix_output "sub var" '(x=inner; echo $x)'
 +compare_posix_output "sub no leak" 'x=outer; (x=inner); echo $x'
 +compare_posix_output "sub exit" '(exit 5); echo $?'
 +compare_posix_output "sub cd" '(cd /tmp; pwd)'
 +compare_posix_output "sub pipe" '(echo a; echo b) | wc -l'
 +# Note: (( )) is arithmetic syntax. Compare exit codes.
 +compare_posix_exit_code "sub nested arithmetic" '((echo deep))'
 +compare_posix_output "sub multi" '(echo a); (echo b)'
++
 +section "260. BRACE GROUP COMPREHENSIVE"
++
 +compare_posix_output "brace echo" '{ echo brace; }'
 +compare_posix_output "brace multi" '{ echo a; echo b; }'
 +compare_posix_output "brace var" '{ x=val; }; echo $x'
 +compare_posix_output "brace pipe" '{ echo test; } | cat'
 +compare_posix_output "brace redir" '{ echo test; } > /tmp/b$$; cat /tmp/b$$; rm /tmp/b$$'
 +compare_posix_output "brace nested" '{ { echo deep; }; }'
 +compare_posix_output "brace and sub" '{ (echo sub); }'
++
 +section "261. SPECIAL CHARACTERS"
++
 +compare_posix_output "char star" 'echo "*"'
 +compare_posix_output "char question" 'echo "?"'
 +compare_posix_output "char bracket" 'echo "[]"'
 +compare_posix_output "char brace" 'echo "{}"'
 +compare_posix_output "char paren" 'echo "()"'
 +compare_posix_output "char pipe" 'echo "|"'
 +compare_posix_output "char amp" 'echo "&"'
 +compare_posix_output "char semi" 'echo ";"'
 +compare_posix_output "char dollar" 'echo "\$"'
 +compare_posix_output "char hash" 'echo "#"'
++
 +section "262. COMMAND LINE PARSING"
++
 +compare_posix_output "parse simple" 'echo hello'
 +compare_posix_output "parse multi arg" 'echo a b c'
 +compare_posix_output "parse quoted arg" 'echo "a b c"'
 +compare_posix_output "parse mixed" 'echo a "b c" d'
 +compare_posix_output "parse empty arg" 'echo "" x'
 +compare_posix_output "parse escape" 'echo a\ b'
 +compare_posix_output "parse continued" 'echo hel\
 +lo'
++
 +section "263. EXECUTION CONTEXT"
++
 +compare_posix_output "exec subshell" '(echo sub)'
 +compare_posix_output "exec pipeline" 'echo test | cat'
 +compare_posix_output "exec background" 'true & echo fg'
 +compare_posix_output "exec compound" '{ echo a; echo b; }'
 +compare_posix_output "exec function" 'f() { echo func; }; f'
 +compare_posix_output "exec builtin" 'echo hello'
 +compare_posix_output "exec external" '/bin/echo hello'
++
 +section "264. STRING COMPARISON"
++
 +compare_posix_output "str eq" '[ "a" = "a" ]; echo $?'
 +compare_posix_output "str ne" '[ "a" != "b" ]; echo $?'
 +compare_posix_output "str lt" '[ "a" \< "b" ]; echo $?'
 +compare_posix_output "str gt" '[ "b" \> "a" ]; echo $?'
 +compare_posix_output "str empty" '[ -z "" ]; echo $?'
 +compare_posix_output "str nonempty" '[ -n "x" ]; echo $?'
 +compare_posix_output "str space" '[ "a b" = "a b" ]; echo $?'
++
 +section "265. NUMERIC COMPARISON"
++
 +compare_posix_output "num eq" '[ 5 -eq 5 ]; echo $?'
 +compare_posix_output "num ne" '[ 5 -ne 6 ]; echo $?'
 +compare_posix_output "num lt" '[ 3 -lt 5 ]; echo $?'
 +compare_posix_output "num gt" '[ 5 -gt 3 ]; echo $?'
 +compare_posix_output "num le" '[ 5 -le 5 ]; echo $?'
 +compare_posix_output "num ge" '[ 5 -ge 5 ]; echo $?'
 +compare_posix_output "num zero" '[ 0 -eq 0 ]; echo $?'
 +compare_posix_output "num neg" '[ -1 -lt 0 ]; echo $?'
++
 +section "266. FILE TESTS COMPREHENSIVE"
++
 +compare_posix_output "file e" '[ -e /tmp ]; echo $?'
 +compare_posix_output "file f" '[ -f /etc/passwd ]; echo $?'
 +compare_posix_output "file d" '[ -d /tmp ]; echo $?'
 +compare_posix_output "file r" '[ -r /etc/passwd ]; echo $?'
 +compare_posix_output "file w" '[ -w /tmp ]; echo $?'
 +compare_posix_output "file x" '[ -x /bin/sh ]; echo $?'
 +compare_posix_output "file s" '[ -s /etc/passwd ]; echo $?'
 +compare_posix_output "file L" '[ -L /dev/stdin ] 2>/dev/null; echo $?'
++
 +section "267. PRINTF FORMAT SPECIFIERS"
++
 +compare_posix_output "printf s" 'printf "%s\n" hello'
 +compare_posix_output "printf d" 'printf "%d\n" 42'
 +compare_posix_output "printf i" 'printf "%i\n" 42'
 +compare_posix_output "printf o" 'printf "%o\n" 8'
 +compare_posix_output "printf x" 'printf "%x\n" 255'
 +compare_posix_output "printf X" 'printf "%X\n" 255'
 +compare_posix_output "printf c" 'printf "%c\n" A'
 +compare_posix_output "printf percent" 'printf "%%\n"'
++
 +section "268. PRINTF WIDTH AND PRECISION"
++
 +compare_posix_output "printf width" 'printf "%5d\n" 42'
 +compare_posix_output "printf zero" 'printf "%05d\n" 42'
 +compare_posix_output "printf left" 'printf "%-5d|\n" 42'
 +compare_posix_output "printf prec" 'printf "%.3s\n" hello'
 +compare_posix_output "printf both" 'printf "%8.3s\n" hello'
++
 +section "269. ECHO OPTIONS"
++
 +compare_posix_output "echo simple" 'echo hello'
 +compare_posix_output "echo multi" 'echo a b c'
 +compare_posix_output "echo n" 'echo -n test; echo done'
 +compare_posix_output "echo e tab" 'echo -e "a\tb"'
 +compare_posix_output "echo e nl" 'echo -e "a\nb" | wc -l'
++
 +section "270. ENVIRONMENT MANIPULATION"
++
 +compare_posix_output "env set" 'X=val; echo $X'
 +compare_posix_output "env export" 'export X=val; echo $X'
 +compare_posix_output "env unset" 'X=val; unset X; echo ${X:-unset}'
 +compare_posix_output "env prefix" 'X=val sh -c "echo \$X"'
 +compare_posix_output "env readonly" 'readonly X=const; echo $X'
 +compare_posix_output "env home" 'echo ${HOME:-none} | grep -c "/"'
 +compare_posix_output "env path" 'echo ${PATH:-none} | grep -c ":"'
 +compare_posix_output "env pwd" 'echo ${PWD:-none} | grep -c "/"'
++
 +section "271. GETOPTS COMPREHENSIVE"
++
 +compare_posix_output "getopts single" 'set -- -a; getopts a opt; echo $opt'
 +compare_posix_output "getopts value" 'set -- -a val; getopts a: opt; echo $opt $OPTARG'
 +compare_posix_output "getopts multi" 'set -- -ab; getopts ab opt; echo $opt'
 +compare_posix_output "getopts optind" 'set -- -a -b; OPTIND=1; getopts ab opt; echo $OPTIND'
 +compare_posix_output "getopts unknown" 'set -- -x; getopts a opt 2>/dev/null; echo $?'
 +compare_posix_output "getopts missing" 'set -- -a; getopts a: opt 2>/dev/null; echo $?'
++
 +section "272. TRAP COMPREHENSIVE"
++
 +# Note: trap output may vary by environment - test exit code
 +compare_posix_exit_code "trap list" 'trap >/dev/null 2>&1'
 +compare_posix_output "trap set" 'trap "echo trapped" INT; trap | grep -c INT || echo 0'
 +compare_posix_output "trap reset" 'trap "echo x" INT; trap - INT; echo done'
 +compare_posix_output "trap ignore" 'trap "" INT; echo done'
 +compare_posix_output "trap exit" 'sh -c "trap \"echo bye\" EXIT; exit 0" 2>/dev/null || echo done'
++
 +section "273. EVAL COMPREHENSIVE"
++
 +compare_posix_output "eval simple" 'eval echo hello'
 +compare_posix_output "eval var" 'x=world; eval echo $x'
 +compare_posix_output "eval quoted" 'eval "echo test"'
 +compare_posix_output "eval multi" 'eval "echo a; echo b" | wc -l'
 +compare_posix_output "eval indirect" 'x=y; y=val; eval echo \$$x'
 +compare_posix_output "eval assign" 'eval "x=test"; echo $x'
 +compare_posix_output "eval complex" 'x="echo hello"; eval $x'
++
 +section "274. EXEC COMPREHENSIVE"
++
 +compare_posix_output "exec fd open" 'exec 3>&1; echo test >&3; exec 3>&-'
 +compare_posix_output "exec fd close" 'exec 3>&1; exec 3>&-; echo ok'
 +compare_posix_output "exec redir" 'exec 3>/tmp/e$$; echo test >&3; exec 3>&-; cat /tmp/e$$; rm /tmp/e$$'
++
 +section "275. DOT SOURCE COMPREHENSIVE"
++
 +compare_posix_output "dot var" 'echo "X=sourced" > /tmp/s$$; . /tmp/s$$; echo $X; rm /tmp/s$$'
 +compare_posix_output "dot func" 'echo "f() { echo func; }" > /tmp/s$$; . /tmp/s$$; f; rm /tmp/s$$'
 +compare_posix_output "dot persist" 'echo "Y=persist" > /tmp/s$$; . /tmp/s$$; echo $Y; rm /tmp/s$$'
++
 +section "276. COMMAND BUILTIN"
++
 +compare_posix_output "command echo" 'command echo hello'
 +compare_posix_output "command v" 'command -v echo | grep -c echo'
 +compare_posix_output "command V" 'command -V echo 2>/dev/null | grep -c echo || echo 1'
 +compare_posix_output "command p" 'command -p echo hello'
 +compare_posix_output "command bypass" 'echo() { printf "func\n"; }; command echo builtin; unset -f echo'
++
 +section "277. TYPE BUILTIN"
++
 +compare_posix_output "type builtin" 'type echo 2>/dev/null | head -1 | grep -c echo || echo 1'
 +compare_posix_output "type external" 'type cat 2>/dev/null | head -1 | grep -c cat || echo 1'
 +compare_posix_output "type notfound" 'type nonexistent_xyz 2>&1 | grep -ci "not found" || echo 0'
++
 +section "278. HASH BUILTIN"
++
 +compare_posix_output "hash show" 'hash 2>/dev/null; echo $?'
 +compare_posix_output "hash clear" 'hash -r 2>/dev/null; echo $?'
++
 +section "279. ULIMIT BUILTIN"
++
 +compare_posix_output "ulimit show" 'ulimit 2>/dev/null | grep -c "[0-9]" || echo 1'
 +compare_posix_output "ulimit n" 'ulimit -n 2>/dev/null | grep -c "[0-9]" || echo 1'
 +# Note: fortsh implements fewer limit types than bash - check both produce output
 +compare_posix_exit_code "ulimit a" 'test $(ulimit -a 2>/dev/null | wc -l) -ge 5'
++
 +section "280. UMASK BUILTIN"
++
 +compare_posix_output "umask show" 'umask | grep -c "[0-7]"'
 +compare_posix_output "umask symbolic" 'umask -S | grep -c "u="'
 +compare_posix_output "umask set" 'old=$(umask); umask 022; umask $old; echo done'
++
 +section "281. TIMES BUILTIN"
++
 +compare_posix_output "times output" 'times 2>&1 | head -1 | grep -c "[0-9]" || echo 0'
++
 +section "282. KILL BUILTIN"
++
 +compare_posix_output "kill list" 'kill -l | head -1 | grep -c "[A-Z]" || echo 1'
 +compare_posix_output "kill l num" 'kill -l 1 2>/dev/null | grep -ci "hup\|term" || echo 0'
++
 +section "283. CD COMPREHENSIVE"
++
 +compare_posix_output "cd tmp" 'cd /tmp && pwd'
 +compare_posix_output "cd home" 'cd ~ && pwd | grep -c "/"'
 +compare_posix_output "cd dash" 'cd /tmp; cd /; cd - 2>/dev/null | grep -c "/" || pwd'
 +compare_posix_output "cd dotdot" 'cd /tmp; cd ..; pwd | grep -v "^/tmp$" | grep -c "/"'
 +compare_posix_output "cd absolute" 'cd /usr && pwd'
 +compare_posix_output "cd relative" 'cd /; cd tmp && pwd'
 +compare_posix_output "cd oldpwd" 'cd /tmp; cd /; echo $OLDPWD | grep -c tmp'
++
 +section "284. PWD COMPREHENSIVE"
++
 +compare_posix_output "pwd basic" 'pwd | grep -c "/"'
 +compare_posix_output "pwd L" 'pwd -L 2>/dev/null | grep -c "/" || pwd | grep -c "/"'
 +compare_posix_output "pwd P" 'pwd -P 2>/dev/null | grep -c "/" || pwd | grep -c "/"'
 +compare_posix_output "pwd var" 'echo $PWD | grep -c "/"'
++
 +section "285. COLON BUILTIN"
++
 +compare_posix_output "colon simple" ':; echo $?'
 +compare_posix_output "colon args" ': arg1 arg2; echo $?'
 +compare_posix_output "colon in if" 'if :; then echo yes; fi'
 +compare_posix_output "colon in while" 'n=0; while :; do n=$((n+1)); [ $n -ge 2 ] && break; done; echo $n'
 +compare_posix_output "colon expansion" ': ${x:=default}; echo $x'
++
 +section "286. TRUE FALSE BUILTINS"
++
 +compare_posix_output "true exit" 'true; echo $?'
 +compare_posix_output "false exit" 'false; echo $?'
 +compare_posix_output "true in if" 'if true; then echo yes; fi'
 +compare_posix_output "false in if" 'if false; then echo no; else echo yes; fi'
 +compare_posix_output "true and" 'true && echo yes'
 +compare_posix_output "false or" 'false || echo yes'
++
 +section "287. RETURN BUILTIN"
++
 +compare_posix_output "return 0" 'f() { return 0; }; f; echo $?'
 +compare_posix_output "return 1" 'f() { return 1; }; f; echo $?'
 +compare_posix_output "return 42" 'f() { return 42; }; f; echo $?'
 +compare_posix_output "return 255" 'f() { return 255; }; f; echo $?'
 +compare_posix_output "return implicit" 'f() { true; }; f; echo $?'
 +compare_posix_output "return last" 'f() { false; }; f; echo $?'
++
 +section "288. EXIT BUILTIN"
++
 +compare_posix_output "exit 0" '(exit 0); echo $?'
 +compare_posix_output "exit 1" '(exit 1); echo $?'
 +compare_posix_output "exit 42" '(exit 42); echo $?'
 +compare_posix_output "exit 255" '(exit 255); echo $?'
 +compare_posix_output "exit implicit" '(true); echo $?'
++
 +section "289. BREAK BUILTIN"
++
 +compare_posix_output "break for" 'for i in 1 2 3; do [ $i -eq 2 ] && break; echo $i; done'
 +compare_posix_output "break while" 'n=0; while true; do n=$((n+1)); [ $n -ge 2 ] && break; done; echo $n'
 +compare_posix_output "break nested" 'for i in 1 2; do for j in a b; do break; done; echo $i; done'
 +compare_posix_output "break 2" 'for i in 1 2; do for j in a b; do break 2; done; done; echo done'
++
 +section "290. CONTINUE BUILTIN"
++
 +compare_posix_output "continue for" 'for i in 1 2 3; do [ $i -eq 2 ] && continue; echo $i; done'
 +compare_posix_output "continue while" 'n=0; while [ $n -lt 3 ]; do n=$((n+1)); [ $n -eq 2 ] && continue; echo $n; done'
 +compare_posix_output "continue nested" 'for i in 1 2; do for j in a b; do continue; done; echo $i; done'
 +compare_posix_output "continue 2" 'for i in 1 2; do for j in a b; do continue 2; done; echo never; done; echo done'
++
 +section "291. SHIFT BUILTIN"
++
 +compare_posix_output "shift once" 'set -- a b c; shift; echo $1'
 +compare_posix_output "shift twice" 'set -- a b c; shift; shift; echo $1'
 +compare_posix_output "shift n" 'set -- a b c d e; shift 3; echo $1'
 +compare_posix_output "shift all" 'set -- a b; shift 2; echo ${1:-empty}'
 +compare_posix_output "shift count" 'set -- a b c; shift; echo $#'
++
 +section "292. SET BUILTIN COMPREHENSIVE"
++
 +compare_posix_output "set args" 'set -- a b c; echo $1 $2 $3'
 +compare_posix_output "set clear" 'set -- a b; set --; echo ${1:-none}'
 +compare_posix_output "set e" 'set -e; true; echo ok'
 +compare_posix_output "set f" 'set -f; echo *; set +f'
 +compare_posix_output "set x" 'set +x; echo ok'
 +compare_posix_output "set minus" 'echo $- | grep -c "."'
 +compare_posix_output "set show" 'X=val; set | grep -c "^X=" || echo 0'
++
 +section "293. UNSET BUILTIN"
++
 +compare_posix_output "unset var" 'X=val; unset X; echo ${X:-gone}'
 +compare_posix_output "unset func" 'f() { echo func; }; unset -f f 2>/dev/null; type f 2>&1 | grep -c "not found" || echo 0'
 +compare_posix_output "unset v" 'X=val; unset -v X; echo ${X:-gone}'
 +compare_posix_output "unset multi" 'X=1 Y=2; unset X Y; echo ${X:-a} ${Y:-b}'
++
 +section "294. EXPORT BUILTIN"
++
 +compare_posix_output "export simple" 'export X=val; echo $X'
 +compare_posix_output "export existing" 'X=val; export X; echo $X'
 +compare_posix_output "export multi" 'export X=1 Y=2; echo $X $Y'
 +compare_posix_output "export child" 'export X=val; sh -c "echo \$X"'
 +compare_posix_output "export list" 'export 2>/dev/null | head -1 | grep -c "=" || echo 0'
++
 +section "295. READONLY BUILTIN"
++
 +compare_posix_output "readonly simple" 'readonly X=val; echo $X'
 +compare_posix_output "readonly existing" 'X=val; readonly X; echo $X'
 +compare_posix_output "readonly list" 'readonly 2>/dev/null | wc -l'
++
 +section "296. LOCAL SCOPE SIMULATION"
++
 +compare_posix_output "scope global" 'X=global; f() { echo $X; }; f'
 +compare_posix_output "scope modify" 'X=old; f() { X=new; }; f; echo $X'
 +compare_posix_output "scope subshell" 'X=outer; (X=inner; echo $X); echo $X'
 +compare_posix_output "scope func arg" 'f() { echo $1; }; f arg'
 +compare_posix_output "scope nested" 'f() { g() { echo inner; }; g; }; f'
++
 +section "297. GLOB PATTERNS COMPREHENSIVE"
++
 +compare_posix_output "glob star" 'set -f; echo *; set +f'
 +compare_posix_output "glob question" 'set -f; echo ?; set +f'
 +compare_posix_output "glob bracket" 'set -f; echo [abc]; set +f'
 +compare_posix_output "glob range" 'set -f; echo [a-z]; set +f'
 +compare_posix_output "glob neg" 'set -f; echo [!abc]; set +f'
 +compare_posix_output "glob quoted" 'echo "*"'
 +compare_posix_output "glob escaped" 'echo \*'
 +compare_posix_output "glob in var" 'x="*"; echo "$x"'
++
 +section "298. TILDE EXPANSION COMPREHENSIVE"
++
 +compare_posix_output "tilde home" 'echo ~ | grep -c "/"'
 +compare_posix_output "tilde slash" 'echo ~/ | grep -c "/"'
 +compare_posix_output "tilde quoted" 'echo "~"'
 +compare_posix_output "tilde var" 'x=~; echo $x | grep -c "/"'
 +compare_posix_output "tilde plus" 'cd /tmp; echo ~+ | grep -c "/"'
 +compare_posix_output "tilde minus" 'cd /tmp; cd /; echo ~- | grep -c tmp'
++
 +section "299. BRACE EXPANSION TESTS"
++
 +compare_posix_output "brace literal" 'echo {a,b,c}'
 +compare_posix_output "brace seq" 'echo {1..3} 2>/dev/null || echo "1 2 3"'
 +compare_posix_output "brace prefix" 'echo pre{a,b} 2>/dev/null || echo "prea preb"'
 +compare_posix_output "brace suffix" 'echo {a,b}suf 2>/dev/null || echo "asuf bsuf"'
++
 +section "300. WORD SPLITTING COMPREHENSIVE"
++
 +compare_posix_output "split default" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "split quoted" 'x="a b c"; set -- "$x"; echo $#'
 +compare_posix_output "split ifs" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "split empty ifs" 'IFS=""; x="a b"; set -- $x; echo $#'
 +compare_posix_output "split unset ifs" 'unset IFS; x="a  b"; set -- $x; echo $#'
 +compare_posix_output "split whitespace" 'x="  a  b  "; set -- $x; echo $#'
 +compare_posix_output "split preserve" 'x="a  b"; echo "$x" | grep -c "  "'
 +compare_posix_output "split tab" 'x="a	b"; set -- $x; echo $#'
++
 +section "301. FIELD SPLITTING EDGE CASES"
++
 +compare_posix_output "field leading" 'IFS=:; x=":a:b"; set -- $x; echo $# $1'
 +compare_posix_output "field trailing" 'IFS=:; x="a:b:"; set -- $x; echo $#'
 +compare_posix_output "field empty" 'IFS=:; x="a::b"; set -- $x; echo $#'
 +compare_posix_output "field multi ifs" 'IFS=":;"; x="a:b;c"; set -- $x; echo $#'
++
 +section "302. COMMAND SUBSTITUTION COMPREHENSIVE"
++
 +compare_posix_output "cmdsub simple" 'echo $(echo hello)'
 +compare_posix_output "cmdsub nested" 'echo $(echo $(echo deep))'
 +compare_posix_output "cmdsub backtick" 'echo `echo hello`'
 +compare_posix_output "cmdsub var" 'x=$(echo val); echo $x'
 +compare_posix_output "cmdsub arith" 'echo $(echo $((1+1)))'
 +compare_posix_output "cmdsub pipe" 'echo $(echo test | cat)'
 +compare_posix_output "cmdsub multiline" 'x=$(printf "a\nb"); echo "$x" | wc -l'
 +# Note: Exit status propagation from command substitution may vary
 +compare_posix_exit_code "cmdsub exit" '$(exit 5); test $? -ne 0'
 +compare_posix_output "cmdsub empty" 'x=$(true); echo "[$x]"'
++
 +section "303. ARITHMETIC EXPANSION COMPREHENSIVE"
++
 +compare_posix_output "arith simple" 'echo $((1+1))'
 +compare_posix_output "arith all ops" 'echo $((2+3-1*2/1%3))'
 +compare_posix_output "arith paren" 'echo $(((1+2)*3))'
 +compare_posix_output "arith var" 'x=5; echo $((x+1))'
 +compare_posix_output "arith compare" 'echo $((5 > 3))'
 +compare_posix_output "arith logical" 'echo $((1 && 1))'
 +compare_posix_output "arith ternary" 'echo $((1 ? 10 : 20))'
 +compare_posix_output "arith nested" 'echo $(($((1+1)) + 1))'
 +compare_posix_output "arith negative" 'echo $((-5))'
 +compare_posix_output "arith zero" 'echo $((0))'
++
 +section "304. PATTERN MATCHING COMPREHENSIVE"
++
 +compare_posix_output "pat suffix" 'x=file.txt; echo ${x%.txt}'
 +compare_posix_output "pat suffix long" 'x=a.b.c; echo ${x%%.*}'
 +compare_posix_output "pat prefix" 'x=prefix_name; echo ${x#prefix_}'
 +compare_posix_output "pat prefix long" 'x=a.b.c; echo ${x##*.}'
 +compare_posix_output "pat star" 'x=hello; echo ${x%l*}'
 +compare_posix_output "pat question" 'x=hello; echo ${x%?}'
 +compare_posix_output "pat no match" 'x=hello; echo ${x%.txt}'
 +compare_posix_output "pat empty" 'x=; echo ${x%.txt}'
++
 +section "305. SPECIAL PARAMETER COMPREHENSIVE"
++
 +compare_posix_output "param zero" 'echo ${0:-shell} | grep -c "."'
 +compare_posix_output "param hash" 'set -- a b c; echo $#'
 +compare_posix_output "param question" 'true; echo $?'
 +compare_posix_output "param dollar" 'echo $$ | grep -c "[0-9]"'
 +compare_posix_output "param at" 'set -- a b c; echo "$@"'
 +compare_posix_output "param star" 'set -- a b c; echo "$*"'
 +compare_posix_output "param minus" 'echo $- | grep -c "."'
 +compare_posix_output "param at loop" 'set -- a b c; for x in "$@"; do echo $x; done | wc -l'
 +compare_posix_output "param star loop" 'set -- a b c; for x in "$*"; do echo $x; done | wc -l'
++
 +section "306. CONTROL FLOW EDGE CASES"
++
 +compare_posix_output "if true simple" 'if true; then echo yes; fi'
 +compare_posix_output "if false simple" 'if false; then echo no; fi; echo done'
 +compare_posix_output "if else" 'if false; then echo no; else echo yes; fi'
 +compare_posix_output "if elif" 'if false; then echo 1; elif true; then echo 2; fi'
 +compare_posix_output "if nested" 'if true; then if true; then echo deep; fi; fi'
 +compare_posix_output "if compound" 'if true && true; then echo yes; fi'
 +compare_posix_output "if pipeline" 'if echo test | grep -q test; then echo yes; fi'
 +compare_posix_output "if negation" 'if ! false; then echo yes; fi'
++
 +section "307. FOR LOOP EDGE CASES"
++
 +compare_posix_output "for basic" 'for i in a b c; do echo $i; done | wc -l'
 +compare_posix_output "for single" 'for i in only; do echo $i; done'
 +compare_posix_output "for empty" 'for i in; do echo $i; done; echo done'
 +compare_posix_output "for numbers" 'for i in 1 2 3 4 5; do echo $i; done | wc -l'
 +compare_posix_output "for var" 'list="a b c"; for i in $list; do echo $i; done | wc -l'
 +compare_posix_output "for quoted" 'for i in "a b" "c d"; do echo "$i"; done | wc -l'
 +compare_posix_output "for break" 'for i in 1 2 3; do [ $i -eq 2 ] && break; echo $i; done'
 +compare_posix_output "for continue" 'for i in 1 2 3; do [ $i -eq 2 ] && continue; echo $i; done'
++
 +section "308. WHILE LOOP EDGE CASES"
++
 +compare_posix_output "while count" 'n=3; while [ $n -gt 0 ]; do echo $n; n=$((n-1)); done | wc -l'
 +compare_posix_output "while false" 'while false; do echo never; done; echo done'
 +compare_posix_output "while true break" 'n=0; while true; do n=$((n+1)); [ $n -ge 3 ] && break; done; echo $n'
 +compare_posix_output "while compound" 'n=2; while [ $n -gt 0 ] && true; do n=$((n-1)); done; echo $n'
 +compare_posix_output "while pipeline" 'echo ok | while true; do echo yes; break; done'
++
 +section "309. UNTIL LOOP EDGE CASES"
++
 +compare_posix_output "until count" 'n=0; until [ $n -ge 3 ]; do n=$((n+1)); done; echo $n'
 +compare_posix_output "until true" 'until true; do echo never; done; echo done'
 +compare_posix_output "until false" 'n=0; until false; do n=$((n+1)); [ $n -ge 2 ] && break; done; echo $n'
++
 +section "310. CASE EDGE CASES"
++
 +compare_posix_output "case simple" 'case x in x) echo yes;; esac'
 +compare_posix_output "case default" 'case x in y) echo no;; *) echo default;; esac'
 +compare_posix_output "case multi" 'case a in a|b|c) echo match;; esac'
 +compare_posix_output "case glob" 'case hello in h*) echo match;; esac'
 +compare_posix_output "case question" 'case ab in ??) echo two;; esac'
 +compare_posix_output "case bracket" 'case a in [abc]) echo match;; esac'
 +compare_posix_output "case empty" 'case "" in "") echo empty;; esac'
 +compare_posix_output "case var" 'x=test; case $x in test) echo yes;; esac'
 +compare_posix_output "case quoted" 'case "a b" in "a b") echo space;; esac'
 +compare_posix_output "case no match" 'case x in y) echo no;; esac; echo done'
++
 +section "311. FUNCTION EDGE CASES"
++
 +compare_posix_output "func simple" 'f() { echo hello; }; f'
 +compare_posix_output "func args" 'f() { echo $1 $2; }; f a b'
 +compare_posix_output "func return" 'f() { return 42; }; f; echo $?'
 +compare_posix_output "func local" 'x=outer; f() { x=inner; }; f; echo $x'
 +compare_posix_output "func recursive" 'f() { [ $1 -le 0 ] && echo done || f $(($1-1)); }; f 3'
 +compare_posix_output "func in func" 'f() { g() { echo inner; }; g; }; f'
 +compare_posix_output "func pipe" 'f() { echo test; }; f | cat'
 +compare_posix_output "func subshell" 'f() { echo func; }; (f)'
 +compare_posix_output "func all args" 'f() { echo $@; }; f a b c'
 +compare_posix_output "func count" 'f() { echo $#; }; f a b c d e'
++
 +section "312. REDIRECTION EDGE CASES"
++
 +compare_posix_output "redir out" 'echo test > /tmp/r$$; cat /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir append" 'echo a > /tmp/r$$; echo b >> /tmp/r$$; wc -l < /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir in" 'echo test > /tmp/r$$; cat < /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir err" 'echo err >&2 2>/dev/null; echo ok'
 +compare_posix_output "redir fd" 'echo test 2>&1 | cat'
 +compare_posix_output "redir null" 'echo test > /dev/null; echo $?'
 +compare_posix_output "redir here" 'cat <<EOF
 +test
 +EOF'
 +compare_posix_output "redir here var" 'x=val; cat <<EOF
 +$x
 +EOF'
++
 +section "313. PIPELINE EDGE CASES"
++
 +compare_posix_output "pipe simple" 'echo test | cat'
 +compare_posix_output "pipe chain" 'echo test | cat | cat | cat'
 +compare_posix_output "pipe grep" 'echo hello | grep h'
 +compare_posix_output "pipe wc" 'printf "a\nb\nc\n" | wc -l'
 +compare_posix_output "pipe head" 'seq 1 10 | head -3'
 +compare_posix_output "pipe tail" 'seq 1 10 | tail -3'
 +compare_posix_output "pipe sort" 'printf "c\na\nb\n" | sort'
 +compare_posix_output "pipe subshell" '(echo test) | cat'
 +compare_posix_output "pipe brace" '{ echo test; } | cat'
 +compare_posix_output "pipe status" 'true | false; echo $?'
++
 +section "314. SUBSHELL EDGE CASES"
++
 +compare_posix_output "sub simple" '(echo sub)'
 +compare_posix_output "sub var" '(x=inner; echo $x)'
 +compare_posix_output "sub no leak" 'x=outer; (x=inner); echo $x'
 +compare_posix_output "sub exit" '(exit 42); echo $?'
 +compare_posix_output "sub cd" '(cd /tmp; pwd)'
 +# Note: (( )) is arithmetic syntax. Compare exit codes.
 +compare_posix_exit_code "sub nested arithmetic" '((echo deep))'
 +compare_posix_output "sub pipe" '(echo a; echo b) | wc -l'
 +compare_posix_output "sub multi" '(echo a); (echo b)'
 +compare_posix_output "sub compound" '(echo a; echo b; echo c) | wc -l'
++
 +section "315. BRACE GROUP EDGE CASES"
++
 +compare_posix_output "brace simple" '{ echo test; }'
 +compare_posix_output "brace multi" '{ echo a; echo b; }'
 +compare_posix_output "brace var" '{ x=val; }; echo $x'
 +compare_posix_output "brace pipe" '{ echo test; } | cat'
 +compare_posix_output "brace nested" '{ { echo deep; }; }'
 +compare_posix_output "brace and sub" '{ (echo sub); }'
 +compare_posix_output "brace redir" '{ echo test; } > /tmp/b$$; cat /tmp/b$$; rm /tmp/b$$'
++
 +section "316. LOGICAL OPERATOR EDGE CASES"
++
 +compare_posix_output "and both true" 'true && true; echo $?'
 +compare_posix_output "and first false" 'false && echo never; echo $?'
 +compare_posix_output "and second false" 'true && false; echo $?'
 +compare_posix_output "or both false" 'false || false; echo $?'
 +compare_posix_output "or first true" 'true || echo never; echo $?'
 +compare_posix_output "or second true" 'false || true; echo $?'
 +compare_posix_output "not true" '! true; echo $?'
 +compare_posix_output "not false" '! false; echo $?'
 +compare_posix_output "chain and" 'true && true && true; echo $?'
 +compare_posix_output "chain or" 'false || false || true; echo $?'
 +compare_posix_output "mixed" 'true && false || echo fallback'
++
 +section "317. QUOTING COMPREHENSIVE"
++
 +compare_posix_output "quote single" "echo 'hello'"
 +compare_posix_output "quote double" 'echo "hello"'
 +compare_posix_output "quote escape" 'echo hello\ world'
 +compare_posix_output "quote mixed" "echo 'a'\"b\"c"
 +compare_posix_output "quote empty single" "echo ''"
 +compare_posix_output "quote empty double" 'echo ""'
 +compare_posix_output "quote dollar" 'echo "\$x"'
 +compare_posix_output "quote backtick" 'echo "\`"'
 +compare_posix_output "quote backslash" 'echo "\\"'
 +compare_posix_output "quote newline" 'echo "a
 +b" | wc -l'
++
 +section "318. VARIABLE COMPREHENSIVE"
++
 +compare_posix_output "var simple" 'x=val; echo $x'
 +compare_posix_output "var empty" 'x=; echo "[$x]"'
 +compare_posix_output "var quoted" 'x="a b"; echo "$x"'
 +compare_posix_output "var concat" 'x=hel; y=lo; echo $x$y'
 +compare_posix_output "var braces" 'x=val; echo ${x}'
 +compare_posix_output "var default" 'echo ${undef:-default}'
 +compare_posix_output "var alt" 'x=val; echo ${x:+alt}'
 +compare_posix_output "var length" 'x=hello; echo ${#x}'
 +compare_posix_output "var suffix" 'x=file.txt; echo ${x%.txt}'
 +compare_posix_output "var prefix" 'x=pre_name; echo ${x#pre_}'
++
 +section "319. ARITHMETIC COMPREHENSIVE"
++
 +compare_posix_output "arith add" 'echo $((5+3))'
 +compare_posix_output "arith sub" 'echo $((5-3))'
 +compare_posix_output "arith mul" 'echo $((5*3))'
 +compare_posix_output "arith div" 'echo $((15/3))'
 +compare_posix_output "arith mod" 'echo $((17%5))'
 +compare_posix_output "arith paren" 'echo $(((1+2)*3))'
 +compare_posix_output "arith var" 'x=5; echo $((x+1))'
 +compare_posix_output "arith neg" 'echo $((-5))'
 +compare_posix_output "arith cmp" 'echo $((5>3))'
 +compare_posix_output "arith log" 'echo $((1&&1))'
++
 +section "320. TEST COMPREHENSIVE"
++
 +compare_posix_output "test eq" '[ 5 -eq 5 ]; echo $?'
 +compare_posix_output "test ne" '[ 5 -ne 6 ]; echo $?'
 +compare_posix_output "test lt" '[ 3 -lt 5 ]; echo $?'
 +compare_posix_output "test gt" '[ 5 -gt 3 ]; echo $?'
 +compare_posix_output "test le" '[ 5 -le 5 ]; echo $?'
 +compare_posix_output "test ge" '[ 5 -ge 5 ]; echo $?'
 +compare_posix_output "test str eq" '[ "a" = "a" ]; echo $?'
 +compare_posix_output "test str ne" '[ "a" != "b" ]; echo $?'
 +compare_posix_output "test z" '[ -z "" ]; echo $?'
 +compare_posix_output "test n" '[ -n "x" ]; echo $?'
 +compare_posix_output "test f" '[ -f /etc/passwd ]; echo $?'
 +compare_posix_output "test d" '[ -d /tmp ]; echo $?'
 +compare_posix_output "test not" '[ ! 1 -eq 2 ]; echo $?'
++
 +# ============================================================================
 +# SECTION 321-340: PARAMETER EXPANSION WITHOUT COLON (POSIX 2.6.2)
 +# These test unset-only behavior vs null-or-unset behavior
 +# ============================================================================
++
 +section "321. USE DEFAULT WITHOUT COLON"
++
 +# ${parameter-word} - substitute word only if parameter is UNSET (not for null)
 +compare_posix_output "default unset only" 'unset x; echo ${x-default}'
 +compare_posix_output "default set empty" 'x=""; echo "[${x-default}]"'
 +compare_posix_output "default set value" 'x=val; echo ${x-default}'
 +compare_posix_output "colon default unset" 'unset x; echo ${x:-default}'
 +compare_posix_output "colon default empty" 'x=""; echo "[${x:-default}]"'
 +compare_posix_output "colon default value" 'x=val; echo ${x:-default}'
++
 +section "322. ASSIGN DEFAULT WITHOUT COLON"
++
 +# ${parameter=word} - assign only if UNSET
 +compare_posix_output "assign unset only" 'unset x; echo ${x=assigned}; echo $x'
 +compare_posix_output "assign set empty" 'x=""; echo "[${x=assigned}]"; echo "[$x]"'
 +compare_posix_output "colon assign unset" 'unset x; echo ${x:=assigned}; echo $x'
 +compare_posix_output "colon assign empty" 'x=""; echo "[${x:=assigned}]"; echo "[$x]"'
++
 +section "323. ERROR IF UNSET WITHOUT COLON"
++
 +# ${parameter?word} - error only if UNSET
 +compare_posix_output "error unset only" '(unset x; echo ${x?errmsg}) 2>/dev/null; echo $?'
 +compare_posix_output "error set empty" 'x=""; echo "[${x?errmsg}]"'
 +compare_posix_output "colon error unset" '(unset x; echo ${x:?errmsg}) 2>/dev/null; echo $?'
 +compare_posix_output "colon error empty" '(x=""; echo ${x:?errmsg}) 2>/dev/null; echo $?'
++
 +section "324. ALT VALUE WITHOUT COLON"
++
 +# ${parameter+word} - substitute word if parameter is SET (even if null)
 +compare_posix_output "alt unset" 'unset x; echo "[${x+alt}]"'
 +compare_posix_output "alt empty" 'x=""; echo "[${x+alt}]"'
 +compare_posix_output "alt value" 'x=val; echo "[${x+alt}]"'
 +compare_posix_output "colon alt unset" 'unset x; echo "[${x:+alt}]"'
 +compare_posix_output "colon alt empty" 'x=""; echo "[${x:+alt}]"'
 +compare_posix_output "colon alt value" 'x=val; echo "[${x:+alt}]"'
++
 +# ============================================================================
 +# SECTION 325-335: SPECIAL PARAMETERS (POSIX 2.5.2)
 +# ============================================================================
++
 +section "325. DOLLAR AT VS DOLLAR STAR"
++
 +compare_posix_output "at basic" 'set -- a b c; echo "$@"'
 +compare_posix_output "star basic" 'set -- a b c; echo "$*"'
 +compare_posix_output "at count" 'set -- a b c; for x in "$@"; do echo $x; done | wc -l'
 +compare_posix_output "star count" 'set -- a b c; for x in "$*"; do echo $x; done | wc -l'
 +compare_posix_output "at with spaces" 'set -- "a b" "c d"; for x in "$@"; do echo "[$x]"; done'
 +compare_posix_output "star with spaces" 'set -- "a b" "c d"; for x in "$*"; do echo "[$x]"; done'
++
 +section "326. IFS AFFECTS DOLLAR STAR"
++
 +compare_posix_output "star ifs colon" 'IFS=:; set -- a b c; echo "$*"'
 +compare_posix_output "star ifs comma" 'IFS=,; set -- x y z; echo "$*"'
 +compare_posix_output "star ifs empty" 'IFS=""; set -- a b c; echo "$*"'
 +compare_posix_output "at ifs colon" 'IFS=:; set -- a b c; echo "$@"'
++
 +section "327. DOLLAR HASH"
++
 +compare_posix_output "hash zero" 'set --; echo $#'
 +compare_posix_output "hash one" 'set -- a; echo $#'
 +compare_posix_output "hash five" 'set -- a b c d e; echo $#'
 +compare_posix_output "hash after shift" 'set -- a b c; shift; echo $#'
++
 +section "328. DOLLAR QUESTION"
++
 +compare_posix_output "question success" 'true; echo $?'
 +compare_posix_output "question fail" 'false; echo $?'
 +compare_posix_output "question exit" '(exit 42); echo $?'
 +compare_posix_output "question pipe" 'true | false; echo $?'
++
 +section "329. DOLLAR HYPHEN"
++
 +compare_posix_output "hyphen basic" 'echo $- | grep -c .'
 +compare_posix_output "hyphen after set" 'set -f; case "$-" in *f*) echo yes;; esac; set +f'
 +compare_posix_output "hyphen in subsh" '(echo $-) | grep -c .'
++
 +section "330. DOLLAR DOLLAR"
++
 +compare_posix_output "pid numeric" 'echo $$ | grep -cE "^[0-9]+$"'
 +compare_posix_output "pid same subsh" 'x=$$; (echo $(( $$ == x ? 1 : 0 )))'
 +compare_posix_output "pid consistent" 'x=$$; echo $(( $$ == x ))'
++
 +section "331. DOLLAR ZERO"
++
 +compare_posix_output "zero set" 'echo $0 | grep -c .'
 +compare_posix_output "zero in func" 'f() { echo $0 | grep -c .; }; f'
++
 +section "332. LINENO VARIABLE"
++
 +compare_posix_output "lineno set" 'echo $LINENO | grep -cE "^[0-9]+$"'
 +compare_posix_output "lineno in script" 'echo "echo \$LINENO" > /tmp/ln$$; sh /tmp/ln$$; rm /tmp/ln$$'
++
 +section "333. PPID VARIABLE"
++
 +compare_posix_output "ppid set" 'echo $PPID | grep -cE "^[0-9]+$"'
 +compare_posix_output "ppid same subsh" '(echo $PPID) | grep -cE "^[0-9]+$"'
 +compare_posix_output "ppid not self" 'test $PPID -ne $$; echo $?'
++
 +section "334. PWD AND OLDPWD"
++
 +compare_posix_output "pwd set" 'echo $PWD | grep -c /'
 +compare_posix_output "pwd equals pwd" 'test "$PWD" = "$(pwd)"; echo $?'
 +compare_posix_output "oldpwd after cd" 'cd /tmp; cd /; echo $OLDPWD | grep -c tmp'
++
 +section "335. PS VARIABLES"
++
 +compare_posix_output "ps1 set" 'echo ${PS1:-unset} | grep -c .'
 +compare_posix_output "ps2 set" 'echo ${PS2:-unset} | grep -c .'
 +compare_posix_output "ps4 default" 'echo ${PS4:-unset} | grep -c .'
++
 +# ============================================================================
 +# SECTION 336-345: ADDITIONAL FILE TEST OPERATORS (POSIX test utility)
 +# ============================================================================
++
 +section "336. TEST TERMINAL FD"
++
 +compare_posix_output "test t stdin" '[ -t 0 ] </dev/null; echo $?'
 +compare_posix_output "test t stdout" '[ -t 1 ] >/dev/null; echo $?'
 +compare_posix_output "test t invalid" '[ -t 999 ]; echo $?'
++
 +section "337. TEST SETUID SETGID"
++
 +compare_posix_output "test u nofile" '[ -u /etc/passwd ]; echo $?'
 +compare_posix_output "test g nofile" '[ -g /etc/passwd ]; echo $?'
++
 +section "338. TEST SPECIAL FILES"
++
 +compare_posix_output "test b regular" '[ -b /etc/passwd ]; echo $?'
 +compare_posix_output "test c regular" '[ -c /etc/passwd ]; echo $?'
 +compare_posix_output "test c tty" '[ -c /dev/tty ] 2>/dev/null; echo $?'
 +compare_posix_output "test p regular" '[ -p /etc/passwd ]; echo $?'
 +compare_posix_output "test S regular" '[ -S /etc/passwd ]; echo $?'
++
 +section "339. TEST FILE PERMS"
++
 +compare_posix_output "test r readable" '[ -r /etc/passwd ]; echo $?'
 +compare_posix_output "test w writable" 'touch /tmp/tw$$; [ -w /tmp/tw$$ ]; echo $?; rm /tmp/tw$$'
 +compare_posix_output "test x dir" '[ -x /tmp ]; echo $?'
 +compare_posix_output "test r nonexist" '[ -r /nonexistent$$ ]; echo $?'
++
 +section "340. TEST STRING PRIMARIES"
++
 +compare_posix_output "test str alone" '[ "nonempty" ]; echo $?'
 +compare_posix_output "test str empty" '[ "" ]; echo $?'
 +compare_posix_output "test str n" '[ -n "abc" ]; echo $?'
 +compare_posix_output "test str n empty" '[ -n "" ]; echo $?'
 +compare_posix_output "test str z" '[ -z "" ]; echo $?'
 +compare_posix_output "test str z non" '[ -z "abc" ]; echo $?'
++
 +section "341. TEST STRING COMPARE"
++
 +compare_posix_output "test str eq" '[ "abc" = "abc" ]; echo $?'
 +compare_posix_output "test str ne" '[ "abc" = "def" ]; echo $?'
 +compare_posix_output "test str neq" '[ "abc" != "def" ]; echo $?'
 +compare_posix_output "test str neq same" '[ "abc" != "abc" ]; echo $?'
++
 +section "342. TEST NUMERIC COMPARE"
++
 +compare_posix_output "test num eq" '[ 5 -eq 5 ]; echo $?'
 +compare_posix_output "test num ne" '[ 5 -ne 3 ]; echo $?'
 +compare_posix_output "test num lt" '[ 3 -lt 5 ]; echo $?'
 +compare_posix_output "test num le" '[ 5 -le 5 ]; echo $?'
 +compare_posix_output "test num gt" '[ 5 -gt 3 ]; echo $?'
 +compare_posix_output "test num ge" '[ 5 -ge 5 ]; echo $?'
 +compare_posix_output "test num neg" '[ -5 -lt 0 ]; echo $?'
++
 +section "343. TEST COMPOUND"
++
 +compare_posix_output "test not" '[ ! -d /tmp ]; echo $?'
 +compare_posix_output "test not false" '[ ! -d /nonexistent ]; echo $?'
 +compare_posix_output "test and" '[ -d /tmp -a -f /etc/passwd ]; echo $?'
 +compare_posix_output "test or" '[ -d /nonexistent -o -f /etc/passwd ]; echo $?'
 +compare_posix_output "test parens" '[ \( -d /tmp \) ]; echo $?'
++
 +section "344. TEST EDGE CASES"
++
 +compare_posix_output "test no args" '[ ]; echo $?'
 +compare_posix_output "test one arg" '[ x ]; echo $?'
 +compare_posix_output "test empty arg" '[ "" ]; echo $?'
 +compare_posix_output "test dash arg" '[ "-n" = "-n" ]; echo $?'
++
 +section "345. TEST BUILTIN BRACKET"
++
 +compare_posix_output "bracket basic" '[ 1 -eq 1 ]; echo $?'
 +compare_posix_output "bracket string" '[ "a" = "a" ]; echo $?'
 +compare_posix_output "bracket file" '[ -f /etc/passwd ]; echo $?'
 +compare_posix_output "bracket missing bracket" '[ 1 -eq 1 2>/dev/null; echo $?'
++
 +# ============================================================================
 +# SECTION 346-355: REDIRECTION (POSIX 2.7)
 +# ============================================================================
++
 +section "346. INPUT REDIRECTION"
++
 +compare_posix_output "redir input" 'echo test > /tmp/ri$$; cat < /tmp/ri$$; rm /tmp/ri$$'
 +compare_posix_output "redir input fd" 'echo test > /tmp/ri$$; cat 0< /tmp/ri$$; rm /tmp/ri$$'
++
 +section "347. OUTPUT REDIRECTION"
++
 +compare_posix_output "redir output" 'echo test > /tmp/ro$$; cat /tmp/ro$$; rm /tmp/ro$$'
 +compare_posix_output "redir output fd" 'echo test 1> /tmp/ro$$; cat /tmp/ro$$; rm /tmp/ro$$'
 +compare_posix_output "redir clobber" 'echo a > /tmp/ro$$; echo b > /tmp/ro$$; cat /tmp/ro$$; rm /tmp/ro$$'
++
 +section "348. APPEND REDIRECTION"
++
 +compare_posix_output "redir append" 'echo a > /tmp/ra$$; echo b >> /tmp/ra$$; cat /tmp/ra$$; rm /tmp/ra$$'
 +compare_posix_output "redir append new" 'rm -f /tmp/ra$$; echo x >> /tmp/ra$$; cat /tmp/ra$$; rm /tmp/ra$$'
++
 +section "349. STDERR REDIRECTION"
++
 +compare_posix_output "redir stderr" 'ls /nonexistent$$ 2>/dev/null; echo done'
 +compare_posix_output "redir stderr to file" 'ls /nonexistent$$ 2>/tmp/re$$; cat /tmp/re$$ | grep -c .; rm /tmp/re$$'
 +compare_posix_output "redir both" '{ echo out; ls /nonexistent$$; } >/tmp/re$$ 2>&1; grep -c . /tmp/re$$; rm /tmp/re$$'
++
 +section "350. FD DUPLICATION"
++
 +compare_posix_output "dup stdout to stderr" 'echo test >&2 2>/tmp/rd$$; cat /tmp/rd$$; rm /tmp/rd$$'
 +compare_posix_output "dup stderr to stdout" '{ ls /nonexistent$$; } 2>&1 | grep -c .'
 +compare_posix_output "dup close" 'exec 3>/tmp/rd$$; echo test >&3; exec 3>&-; cat /tmp/rd$$; rm /tmp/rd$$'
++
 +section "351. READ WRITE REDIRECTION"
++
 +compare_posix_output "redir rw" 'echo test > /tmp/rw$$; exec 3<>/tmp/rw$$; cat <&3; exec 3>&-; rm /tmp/rw$$'
++
 +section "352. HEREDOC BASIC"
++
 +compare_posix_output "heredoc simple" 'cat <<EOF
 +hello
 +EOF'
 +compare_posix_output "heredoc multi" 'cat <<EOF
 +line1
 +line2
 +line3
 +EOF'
++
 +section "353. HEREDOC EXPANSION"
++
 +compare_posix_output "heredoc var" 'x=value; cat <<EOF
 +$x
 +EOF'
 +compare_posix_output "heredoc cmd" 'cat <<EOF
 +$(echo hello)
 +EOF'
 +compare_posix_output "heredoc arith" 'cat <<EOF
 +$((1+2))
 +EOF'
++
 +section "354. HEREDOC QUOTED DELIM"
++
 +compare_posix_output "heredoc no expand" "cat <<'EOF'
 +\$x
 +EOF"
 +compare_posix_output "heredoc quote double" 'cat <<"EOF"
 +$x
 +EOF'
++
 +section "355. HEREDOC TAB STRIP"
++
 +compare_posix_output "heredoc dash" 'cat <<-EOF
 +	hello
 +	EOF'
++
 +# ============================================================================
 +# SECTION 356-365: SPECIAL BUILTINS ERROR HANDLING (POSIX 2.14)
 +# ============================================================================
++
 +section "356. BREAK CONTINUE"
++
 +compare_posix_output "break basic" 'for i in 1 2 3; do echo $i; break; done'
 +compare_posix_output "break nested" 'for i in 1 2; do for j in a b; do echo $i$j; break; done; done'
 +compare_posix_output "break 2" 'for i in 1 2; do for j in a b; do echo $i$j; break 2; done; done'
 +compare_posix_output "continue basic" 'for i in 1 2 3; do if [ $i = 2 ]; then continue; fi; echo $i; done'
 +compare_posix_output "continue 2" 'for i in 1 2 3; do for j in a b; do if [ $j = a ]; then continue 2; fi; echo $i$j; done; done'
++
 +section "357. COLON COMMAND"
++
 +compare_posix_output "colon return" ': ; echo $?'
 +compare_posix_output "colon with args" ': arg1 arg2 arg3; echo $?'
 +compare_posix_output "colon expansion" 'unset x; : ${x:=default}; echo $x'
++
 +section "358. DOT COMMAND"
++
 +compare_posix_output "dot source" 'echo "x=sourced" > /tmp/ds$$; . /tmp/ds$$; echo $x; rm /tmp/ds$$'
 +compare_posix_output "dot with args" 'echo "echo \$1 \$2" > /tmp/ds$$; . /tmp/ds$$ arg1 arg2; rm /tmp/ds$$'
 +compare_posix_output "dot function" 'echo "f() { echo func; }" > /tmp/ds$$; . /tmp/ds$$; f; rm /tmp/ds$$'
++
 +section "359. EVAL COMMAND"
++
 +compare_posix_output "eval basic" 'eval echo hello'
 +compare_posix_output "eval var" 'x=echo; eval $x world'
 +compare_posix_output "eval multi" 'eval "echo one; echo two"'
 +compare_posix_output "eval indirect" 'x=y; y=value; eval echo \$$x'
 +compare_posix_output "eval quote" 'eval "echo \"quoted\""'
++
 +section "360. EXEC COMMAND"
++
 +compare_posix_output "exec redirect" 'exec 3>/tmp/ex$$; echo test >&3; exec 3>&-; cat /tmp/ex$$; rm /tmp/ex$$'
 +compare_posix_output "exec input" 'echo test > /tmp/ex$$; exec 4</tmp/ex$$; cat <&4; exec 4<&-; rm /tmp/ex$$'
++
 +section "361. EXIT COMMAND"
++
 +compare_posix_output "exit basic" '(exit); echo $?'
 +compare_posix_output "exit code" '(exit 5); echo $?'
 +compare_posix_output "exit 0" '(exit 0); echo $?'
 +compare_posix_output "exit 255" '(exit 255); echo $?'
++
 +section "362. EXPORT COMMAND"
++
 +compare_posix_output "export basic" 'export X=5; sh -c "echo \$X"'
 +compare_posix_output "export separate" 'Y=6; export Y; sh -c "echo \$Y"'
 +compare_posix_output "export list" 'export | grep -c ='
 +compare_posix_output "export unset" 'export Z=7; unset Z; sh -c "echo \${Z:-unset}"'
++
 +section "363. READONLY COMMAND"
++
 +compare_posix_output "readonly basic" 'readonly X=5; echo $X'
 +compare_posix_output "readonly list" 'readonly | grep -c .'
 +compare_posix_output "readonly modify" '(readonly Y=1; Y=2) 2>/dev/null; echo $?'
++
 +section "364. RETURN COMMAND"
++
 +compare_posix_output "return basic" 'f() { return; }; f; echo $?'
 +compare_posix_output "return code" 'f() { return 5; }; f; echo $?'
 +compare_posix_output "return from func" 'f() { echo before; return 3; echo after; }; f; echo $?'
++
 +section "365. SET COMMAND"
++
 +compare_posix_output "set args" 'set -- a b c; echo $1 $2 $3'
 +compare_posix_output "set count" 'set -- a b c d e; echo $#'
 +compare_posix_output "set clear" 'set -- a b; set --; echo $#'
 +compare_posix_output "set option f" 'set -f; echo $- | grep -c f; set +f'
 +compare_posix_output "set minus" 'set -x; set +x; echo ok'
++
 +# ============================================================================
 +# SECTION 366-375: MORE SPECIAL BUILTINS
 +# ============================================================================
++
 +section "366. SHIFT COMMAND"
++
 +compare_posix_output "shift basic" 'set -- a b c; shift; echo $1'
 +compare_posix_output "shift count" 'set -- a b c; shift; echo $#'
 +compare_posix_output "shift 2" 'set -- a b c d; shift 2; echo $1'
 +compare_posix_output "shift all" 'set -- a b; shift 2; echo $#'
++
 +section "367. TIMES COMMAND"
++
 +compare_posix_output "times output" 'times 2>/dev/null | wc -l | xargs test 0 -lt && echo ok || echo ok'
++
 +section "368. TRAP COMMAND"
++
 +# Note: trap output may vary by environment - test exit code
 +compare_posix_exit_code "trap list" 'trap >/dev/null 2>&1'
 +compare_posix_output "trap exit" 'trap "echo trapped" EXIT; exit 0'
 +compare_posix_output "trap reset" 'trap "" INT; trap - INT; echo ok'
++
 +section "369. UNSET COMMAND"
++
 +compare_posix_output "unset var" 'x=5; unset x; echo ${x:-unset}'
 +compare_posix_output "unset func" 'f() { echo func; }; unset -f f; f 2>/dev/null || echo unset'
 +compare_posix_output "unset v flag" 'x=5; unset -v x; echo ${x:-unset}'
++
 +section "370. ALIAS COMMAND"
++
 +compare_posix_output "alias set" 'alias ll="ls -l" 2>/dev/null; alias ll 2>/dev/null | grep -c ll || echo 0'
 +compare_posix_output "alias list" 'alias 2>/dev/null; echo $?'
 +compare_posix_output "unalias" 'alias xx="echo xx" 2>/dev/null; unalias xx 2>/dev/null; echo $?'
++
 +section "371. COMMAND BUILTIN"
++
 +compare_posix_output "command v" 'command -v echo | grep -c echo'
 +compare_posix_output "command V" 'command -V echo 2>/dev/null | grep -c echo'
 +compare_posix_output "command p" 'command -p echo test'
 +compare_posix_output "command bypass" 'echo() { printf "func\n"; }; command echo real; unset -f echo'
++
 +section "372. GETOPTS COMMAND"
++
 +compare_posix_output "getopts basic" 'set -- -a; getopts a opt; echo $opt'
 +compare_posix_output "getopts optarg" 'set -- -b val; getopts b: opt; echo $opt $OPTARG'
 +compare_posix_output "getopts optind" 'set -- -a arg; getopts a opt; echo $OPTIND'
++
 +section "373. READ COMMAND OPTIONS"
++
 +compare_posix_output "read r flag" 'echo "a\\b" > /tmp/rr$$; read -r x < /tmp/rr$$; echo $x; rm /tmp/rr$$'
 +compare_posix_output "read multiple" 'echo "a b c" > /tmp/rm$$; read x y z < /tmp/rm$$; echo "$x:$y:$z"; rm /tmp/rm$$'
 +compare_posix_output "read extra" 'echo "a b c d" > /tmp/re$$; read x y < /tmp/re$$; echo "$x:$y"; rm /tmp/re$$'
++
 +section "374. PRINTF COMMAND"
++
 +compare_posix_output "printf basic" 'printf "hello\n"'
 +compare_posix_output "printf format s" 'printf "%s\n" world'
 +compare_posix_output "printf format d" 'printf "%d\n" 42'
 +compare_posix_output "printf format x" 'printf "%x\n" 255'
 +compare_posix_output "printf format o" 'printf "%o\n" 8'
 +compare_posix_output "printf width" 'printf "%5d\n" 42'
 +compare_posix_output "printf left" 'printf "%-5d|\n" 42'
 +compare_posix_output "printf zero" 'printf "%05d\n" 42'
 +compare_posix_output "printf multi" 'printf "%s %s\n" hello world'
++
 +section "375. ECHO COMMAND"
++
 +compare_posix_output "echo basic" 'echo hello'
 +compare_posix_output "echo multi" 'echo hello world'
 +compare_posix_output "echo empty" 'echo ""'
 +compare_posix_output "echo n flag" 'echo -n hello; echo world'
 +compare_posix_output "echo escapes" 'echo "a\tb"'
++
 +# ============================================================================
 +# SECTION 376-385: WORD EXPANSION EDGE CASES
 +# ============================================================================
++
 +section "376. TILDE EXPANSION"
++
 +compare_posix_output "tilde home" 'echo ~ | grep -c /'
 +compare_posix_output "tilde slash" 'echo ~/ | grep -c /'
 +compare_posix_output "tilde plus" 'echo ~+ | grep -c /'
 +compare_posix_output "tilde minus" 'OLDPWD=/tmp; echo ~-'
 +compare_posix_output "tilde quoted" 'echo "~"'
 +compare_posix_output "tilde mid word" 'echo a~b'
 +compare_posix_output "tilde in assign" 'x=~/test; echo $x | grep -c /'
++
 +section "377. PATHNAME EXPANSION"
++
 +compare_posix_output "glob star" 'mkdir -p /tmp/pg$$; touch /tmp/pg$$/a /tmp/pg$$/b; echo /tmp/pg$$/* | grep -c pg; rm -rf /tmp/pg$$'
 +compare_posix_output "glob question" 'mkdir -p /tmp/pg$$; touch /tmp/pg$$/ab; echo /tmp/pg$$/a? | grep -c ab; rm -rf /tmp/pg$$'
 +compare_posix_output "glob bracket" 'mkdir -p /tmp/pg$$; touch /tmp/pg$$/a1 /tmp/pg$$/a2; ls /tmp/pg$$/a[12] | wc -l; rm -rf /tmp/pg$$'
 +compare_posix_output "glob negate" 'mkdir -p /tmp/pg$$; touch /tmp/pg$$/a1 /tmp/pg$$/b1; ls /tmp/pg$$/[!a]1 | wc -l; rm -rf /tmp/pg$$'
 +compare_posix_output "glob range" 'mkdir -p /tmp/pg$$; touch /tmp/pg$$/a1 /tmp/pg$$/b1 /tmp/pg$$/c1; ls /tmp/pg$$/[a-c]1 | wc -l; rm -rf /tmp/pg$$'
 +# Note: Use fixed path since $$ differs between shells
 +compare_posix_output "glob no match" 'echo /definitely_nonexistent_xyz/*'
++
 +section "378. FIELD SPLITTING"
++
 +compare_posix_output "split default" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "split tab" 'x="a	b	c"; set -- $x; echo $#'
 +compare_posix_output "split newline" 'x="a
 +b
 +c"; set -- $x; echo $#'
 +compare_posix_output "split ifs colon" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "split ifs multi" 'IFS=":;"; x="a:b;c"; set -- $x; echo $#'
 +compare_posix_output "split no split" 'x="a b c"; set -- "$x"; echo $#'
++
 +section "379. QUOTE REMOVAL"
++
 +compare_posix_output "quote remove single" "echo 'hello'"
 +compare_posix_output "quote remove double" 'echo "hello"'
 +compare_posix_output "quote remove escape" 'echo hello\ world'
 +compare_posix_output "quote remove mixed" "echo 'a'b'c'"
 +compare_posix_output "quote remove empty" "echo ''"
 +compare_posix_output "quote preserve space" 'echo "a   b"'
++
 +section "380. COMMAND SUBSTITUTION"
++
 +compare_posix_output "cmd sub basic" 'echo $(echo hello)'
 +compare_posix_output "cmd sub backtick" 'echo `echo hello`'
 +compare_posix_output "cmd sub nested" 'echo $(echo $(echo deep))'
 +compare_posix_output "cmd sub quote" 'echo "$(echo "hello world")"'
 +compare_posix_output "cmd sub multi" 'echo $(echo a; echo b)'
 +compare_posix_output "cmd sub exit" 'echo $(exit 5); echo $?'
++
 +section "381. ARITHMETIC EXPANSION"
++
 +compare_posix_output "arith basic" 'echo $((1+2))'
 +compare_posix_output "arith var" 'x=5; echo $((x*2))'
 +compare_posix_output "arith nested" 'echo $(( $((1+2)) + 3 ))'
 +compare_posix_output "arith in string" 'echo "result: $((3*4))"'
 +compare_posix_output "arith negative" 'echo $((-5))'
++
 +section "382. PARAMETER LENGTH"
++
 +compare_posix_output "length basic" 'x=hello; echo ${#x}'
 +compare_posix_output "length empty" 'x=""; echo ${#x}'
 +compare_posix_output "length special" 'set -- a b c; echo ${#@}'
 +compare_posix_output "length star" 'set -- a b c; echo ${#*}'
++
 +section "383. PATTERN SUFFIX REMOVAL"
++
 +compare_posix_output "suffix short" 'x=file.txt; echo ${x%.txt}'
 +compare_posix_output "suffix long" 'x=file.tar.gz; echo ${x%%.*}'
 +compare_posix_output "suffix star" 'x=abcabc; echo ${x%abc}'
 +compare_posix_output "suffix star long" 'x=abcabc; echo ${x%%a*}'
 +compare_posix_output "suffix no match" 'x=hello; echo ${x%.xyz}'
++
 +section "384. PATTERN PREFIX REMOVAL"
++
 +compare_posix_output "prefix short" 'x=prefix_name; echo ${x#prefix_}'
 +compare_posix_output "prefix long" 'x=/usr/local/bin; echo ${x##*/}'
 +compare_posix_output "prefix star" 'x=abcabc; echo ${x#abc}'
 +compare_posix_output "prefix star long" 'x=abcabc; echo ${x##*a}'
 +compare_posix_output "prefix no match" 'x=hello; echo ${x#xyz}'
++
 +section "385. EXPANSION ORDER"
++
 +compare_posix_output "order brace tilde" 'echo ~/{a,b} | grep -c /'
 +compare_posix_output "order param cmd" 'x=$(echo val); echo $x'
 +compare_posix_output "order arith param" 'x=5; echo $((x+1))'
 +compare_posix_output "order split glob" 'mkdir -p /tmp/eo$$; touch /tmp/eo$$/f1; x="/tmp/eo$$/f*"; echo $x | grep -c f; rm -rf /tmp/eo$$'
++
 +# ============================================================================
 +# SECTION 386-400: POSIX CHARACTER CLASSES (basedefs/V1_chap09)
 +# ============================================================================
++
 +section "401. IFS EDGE CASES"
++
 +compare_posix_output "ifs default split" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "ifs null no split" 'IFS=""; x="abc"; set -- $x; echo $#'
 +compare_posix_output "ifs custom colon" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "ifs whitespace" 'IFS=" "; x="a  b"; set -- $x; echo $#'
++
 +section "402. HOME VARIABLE"
++
 +compare_posix_output "home set" 'echo ${HOME:-unset} | grep -c /'
 +compare_posix_output "home in tilde" 'test ~ = "$HOME"; echo $?'
++
 +section "403. PATH VARIABLE"
++
 +compare_posix_output "path set" 'echo ${PATH:-unset} | grep -c :'
 +compare_posix_output "path search" 'PATH=/bin:/usr/bin; command -v ls | grep -c /'
++
 +section "404. SHELL OPTION FLAGS"
++
 +compare_posix_output "set f noglob" 'set -f; echo *; set +f'
 +compare_posix_output "set u nounset" '(set -u; echo ${x:-default})'
 +compare_posix_output "set e errexit" '(set -e; true; echo ok)'
 +# Note: xtrace redirection through pipes differs - check both produce output
 +compare_posix_exit_code "set x xtrace" 'test "$(set -x; echo xtrace_test 2>&1 | grep -c xtrace)" -ge 1'
++
 +section "405. EXIT STATUS PROPAGATION"
++
 +compare_posix_output "exit from pipe" 'true | false; echo $?'
 +compare_posix_output "exit from and" 'true && true; echo $?'
 +compare_posix_output "exit from or" 'false || true; echo $?'
 +compare_posix_output "exit from not" '! false; echo $?'
++
 +section "406. SUBSHELL ISOLATION"
++
 +compare_posix_output "subshell var" 'x=1; (x=2); echo $x'
 +compare_posix_output "subshell cd" 'cd /tmp; (cd /); pwd | grep -c tmp'
 +compare_posix_output "subshell exit" '(exit 5); echo $?'
++
 +section "407. BRACE GROUP SEMANTICS"
++
 +compare_posix_output "brace var" 'x=1; { x=2; }; echo $x'
 +compare_posix_output "brace redir" '{ echo a; echo b; } > /tmp/bg$$; wc -l < /tmp/bg$$; rm /tmp/bg$$'
++
 +section "408. FUNCTION SEMANTICS"
++
 +compare_posix_output "func scope" 'x=1; f() { x=2; }; f; echo $x'
 +compare_posix_output "func params" 'f() { echo $1 $2 $#; }; f a b c'
 +compare_posix_output "func return" 'f() { return 42; }; f; echo $?'
++
 +section "409. ALIAS EXPANSION"
++
 +compare_posix_output "alias define" 'alias x="echo test" 2>/dev/null; echo $?'
 +compare_posix_output "unalias" 'alias x="echo test" 2>/dev/null; unalias x 2>/dev/null; echo $?'
++
 +section "410. COMPOUND ASSIGNMENT"
++
 +compare_posix_output "assign simple" 'x=5; echo $x'
 +compare_posix_output "assign expand" 'x=$(echo val); echo $x'
 +compare_posix_output "assign arith" 'x=$((2+3)); echo $x'
 +compare_posix_output "assign concat" 'x=hel; x=${x}lo; echo $x'
++
 +# ============================================================================
 +# SECTION 411-420: COMPLEX PATTERNS
 +# ============================================================================
++
 +section "411. CASE PATTERN MATCHING"
++
 +compare_posix_output "case star" 'case abc in a*) echo yes;; esac'
 +compare_posix_output "case question" 'case ab in a?) echo yes;; esac'
 +compare_posix_output "case bracket" 'case a in [abc]) echo yes;; esac'
 +compare_posix_output "case or" 'case b in a|b|c) echo yes;; esac'
 +compare_posix_output "case default" 'case x in a) echo a;; *) echo default;; esac'
++
 +section "412. GLOB PATTERNS IN EXPANSION"
++
 +compare_posix_output "glob files" 'mkdir -p /tmp/gt$$; touch /tmp/gt$$/a /tmp/gt$$/b; ls /tmp/gt$$/* | wc -l; rm -rf /tmp/gt$$'
 +compare_posix_output "glob question" 'mkdir -p /tmp/gt$$; touch /tmp/gt$$/ab; echo /tmp/gt$$/a? | grep -c ab; rm -rf /tmp/gt$$'
 +# Note: Use fixed path since $$ differs between shells
 +compare_posix_output "glob no match" 'echo /definitely_nonexistent_abc/*'
++
 +section "413. SUFFIX REMOVAL PATTERNS"
++
 +compare_posix_output "suffix short" 'x=file.txt; echo ${x%.txt}'
 +compare_posix_output "suffix long" 'x=file.tar.gz; echo ${x%%.*}'
 +compare_posix_output "suffix star" 'x=path/to/file; echo ${x%/*}'
++
 +section "414. PREFIX REMOVAL PATTERNS"
++
 +compare_posix_output "prefix short" 'x=file.txt; echo ${x#*.}'
 +compare_posix_output "prefix long" 'x=file.tar.gz; echo ${x##*.}'
 +compare_posix_output "prefix path" 'x=/path/to/file; echo ${x##*/}'
++
 +section "415. LENGTH OPERATOR"
++
 +compare_posix_output "length string" 'x=hello; echo ${#x}'
 +compare_posix_output "length empty" 'x=""; echo ${#x}'
 +compare_posix_output "length positional" 'set -- a b c; echo $#'
++
 +section "416. CONDITIONAL DEFAULTS"
++
 +compare_posix_output "default unset" 'unset x; echo ${x:-default}'
 +compare_posix_output "default empty" 'x=""; echo ${x:-default}'
 +compare_posix_output "default set" 'x=val; echo ${x:-default}'
++
 +section "417. CONDITIONAL ASSIGN"
++
 +compare_posix_output "assign unset" 'unset x; echo ${x:=assigned}; echo $x'
 +compare_posix_output "assign empty" 'x=""; echo ${x:=assigned}; echo $x'
++
 +section "418. CONDITIONAL ERROR"
++
 +compare_posix_output "error unset" '(unset x; echo ${x:?msg}) 2>/dev/null; echo $?'
 +compare_posix_output "error set" 'x=val; echo ${x:?msg}'
++
 +section "419. CONDITIONAL ALT"
++
 +compare_posix_output "alt unset" 'unset x; echo "[${x:+alt}]"'
 +compare_posix_output "alt set" 'x=val; echo "[${x:+alt}]"'
++
 +section "420. NESTED PARAMETER"
++
 +compare_posix_output "nested default" 'y=inner; echo ${x:-${y:-outer}}'
 +compare_posix_output "nested length" 'x=hello; echo $((${#x} + 1))'
++
 +# ============================================================================
 +# SECTION 421-430: HEREDOC VARIATIONS
 +# ============================================================================
++
 +section "441. SIMPLE COMMANDS"
++
 +compare_posix_output "simple echo" 'echo hello'
 +compare_posix_output "simple true" 'true; echo $?'
 +compare_posix_output "simple false" 'false; echo $?'
 +compare_posix_output "simple colon" ': ; echo $?'
++
 +section "442. PIPELINES"
++
 +compare_posix_output "pipe simple" 'echo hello | cat'
 +compare_posix_output "pipe multi" 'echo hello | cat | cat'
 +compare_posix_output "pipe exit" 'true | false; echo $?'
 +compare_posix_output "pipe negation" '! echo x | grep y 2>/dev/null; echo $?'
++
 +section "443. LISTS"
++
 +compare_posix_output "list semi" 'echo a; echo b'
 +compare_posix_output "list newline" 'echo a
 +echo b'
 +compare_posix_output "list and" 'true && echo yes'
 +compare_posix_output "list or" 'false || echo yes'
++
 +section "444. COMPOUND COMMANDS"
++
 +compare_posix_output "subshell" '(echo hello)'
 +compare_posix_output "brace" '{ echo hello; }'
 +compare_posix_output "if" 'if true; then echo yes; fi'
 +compare_posix_output "for" 'for i in a b; do echo $i; done'
 +compare_posix_output "case" 'case x in x) echo yes;; esac'
++
 +section "448. WORD SPLITTING"
++
 +compare_posix_output "split default" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "split quoted" 'x="a b c"; set -- "$x"; echo $#'
 +compare_posix_output "split ifs" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
++
 +section "449. GLOB EXPANSION"
++
 +compare_posix_output "glob star" 'mkdir -p /tmp/g$$; touch /tmp/g$$/a; echo /tmp/g$$/* | grep -c g; rm -rf /tmp/g$$'
 +compare_posix_output "glob question" 'mkdir -p /tmp/g$$; touch /tmp/g$$/ab; echo /tmp/g$$/a? | grep -c ab; rm -rf /tmp/g$$'
 +compare_posix_output "glob bracket" 'mkdir -p /tmp/g$$; touch /tmp/g$$/a1; echo /tmp/g$$/a[12] | grep -c a1; rm -rf /tmp/g$$'
 +# Note: Use fixed path since $$ differs between shells
 +compare_posix_output "glob nomatch" 'echo /definitely_nonexistent_def/*'
++
 +section "450. TILDE EXPANSION"
++
 +compare_posix_output "tilde home" 'echo ~ | grep -c /'
 +compare_posix_output "tilde plus" 'echo ~+ | grep -c /'
 +compare_posix_output "tilde in assign" 'x=~/test; echo $x | grep -c /'
 +compare_posix_output "tilde quoted" 'echo "~"'
++
 +# ============================================================================
 +# SECTION 451-460: BUILTINS EDGE CASES
 +# ============================================================================
++
 +# Summary
 +printf "\n"
 +printf "==========================================\n"
 +printf "GAP COVERAGE POSIX COMPLIANCE TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +if [ $((PASSED + FAILED)) -gt 0 ]; then
 +    PASS_RATE=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%%\n" "$PASS_RATE"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    if [ -n "$DEBUG_INFO" ]; then
 +        printf "\n${YELLOW}Debug info:${NC}\n%b" "$DEBUG_INFO"
 +    fi
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL GAP COVERAGE TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_compliance_heredoc.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Here-Document and Expansion Test Suite for fortsh
 +# =====================================
 +# Tests here-documents and parameter expansion per IEEE Std 1003.1-2017
 +# Section: Shell Command Language - Here-Documents, Parameter Expansion
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-heredoc]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# =====================================
 +section "396. BASIC HERE-DOCUMENT"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'cat <<EOF
 +hello world
 +EOF' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "Basic here-document"
 +else
 +    fail "Basic here-document" "hello world" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'cat <<END
 +line one
 +line two
 +END' 2>&1)
 +expected=$(printf "line one\nline two")
 +if [ "$result" = "$expected" ]; then
 +    pass "Here-document multiple lines"
 +else
 +    fail "Here-document multiple lines" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=world; cat <<EOF
 +hello $x
 +EOF' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "Here-document with variable expansion"
 +else
 +    fail "Here-document with variable expansion" "hello world" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'cat <<EOF
 +result: $(echo test)
 +EOF' 2>&1)
 +if [ "$result" = "result: test" ]; then
 +    pass "Here-document with command substitution"
 +else
 +    fail "Here-document with command substitution" "result: test" "$result"
 +fi
++
 +# =====================================
 +section "397. QUOTED HERE-DOCUMENT DELIMITER"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'x=world; cat <<"EOF"
 +hello $x
 +EOF' 2>&1)
 +if [ "$result" = 'hello $x' ]; then
 +    pass "Quoted delimiter prevents expansion"
 +else
 +    fail "Quoted delimiter prevents expansion" 'hello $x' "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c "cat <<'END'
 +test \$(echo foo)
 +END" 2>&1)
 +if [ "$result" = 'test $(echo foo)' ]; then
 +    pass "Single-quoted delimiter prevents command sub"
 +else
 +    fail "Single-quoted delimiter prevents command sub" 'test $(echo foo)' "$result"
 +fi
++
 +# =====================================
 +section "398. HERE-DOCUMENT WITH TAB STRIPPING (<<-)"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c '	cat <<-EOF
 +	hello
 +	world
 +	EOF' 2>&1)
 +expected=$(printf "hello\nworld")
 +if [ "$result" = "$expected" ]; then
 +    pass "<<- strips leading tabs"
 +else
 +    fail "<<- strips leading tabs" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'cat <<-END
 +		indented
 +	END' 2>&1)
 +if [ "$result" = "indented" ]; then
 +    pass "<<- strips multiple tabs"
 +else
 +    fail "<<- strips multiple tabs" "indented" "$result"
 +fi
++
 +# =====================================
 +section "399. HERE-DOCUMENT TO DIFFERENT COMMANDS"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'wc -l <<EOF
 +one
 +two
 +three
 +EOF' 2>&1)
 +if echo "$result" | grep -q "3"; then
 +    pass "Here-document to wc -l"
 +else
 +    fail "Here-document to wc -l" "3" "$result"
 +fi
++
 +# Note: read with heredoc can hang if not implemented - use timeout
 +# Portable: macOS lacks GNU timeout
 +if command -v timeout >/dev/null 2>&1; then
 +    _timeout() { timeout "$@"; }
 +elif command -v gtimeout >/dev/null 2>&1; then
 +    _timeout() { gtimeout "$@"; }
 +else
 +    _timeout() {
 +        _to_secs="$1"; shift
 +        _to_tmp=$(mktemp /tmp/fortsh_timeout.XXXXXX)
 +        ( "$@" ) > "$_to_tmp" 2>&1 &
 +        _to_pid=$!
 +        ( sleep "$_to_secs"; kill "$_to_pid" 2>/dev/null ) &
 +        _to_wd=$!
 +        wait "$_to_pid" 2>/dev/null
 +        _to_rc=$?
 +        kill "$_to_wd" 2>/dev/null
 +        wait "$_to_wd" 2>/dev/null
 +        cat "$_to_tmp"
 +        rm -f "$_to_tmp"
 +        return $_to_rc
 +    }
 +fi
 +result=$(_timeout 2 "$FORTSH_BIN" -c 'read x <<EOF
 +test input
 +EOF
 +echo "$x"' 2>&1)
 +exit_code=$?
 +if [ "$result" = "test input" ]; then
 +    pass "Here-document to read"
 +elif [ $exit_code -eq 124 ]; then
 +    fail "Here-document to read" "test input" "(timeout - hangs)"
 +else
 +    fail "Here-document to read" "test input" "$result"
 +fi
++
 +# =====================================
 +section "400. PARAMETER EXPANSION ${var:-default}"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +if [ "$result" = "" ]; then
 +    pass "\${var-default} for empty (no colon)"
 +else
 +    fail "\${var-default} for empty (no colon)" "(empty)" "$result"
 +fi
++
 +# =====================================
 +section "401. PARAMETER EXPANSION ${var:+alternate}"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "" ]; then
 +    pass "\${var:+alternate} for empty variable"
 +else
 +    fail "\${var:+alternate} for empty variable" "(empty)" "$result"
 +fi
++
 +# =====================================
 +section "402. PARAMETER EXPANSION ${var:=assign}"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    fail "\${var:=value} assigns when unset" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=""; echo ${x:=assigned}; echo $x' 2>&1)
 +expected=$(printf "assigned\nassigned")
 +if [ "$result" = "$expected" ]; then
 +    pass "\${var:=value} assigns when empty"
 +else
 +    fail "\${var:=value} assigns when empty" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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"
 +else
 +    fail "\${var:=value} keeps original when set" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "403. PARAMETER EXPANSION ${var:?error}"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -qi "error\|custom"; then
 +    pass "\${var:?error} shows error when unset"
 +else
 +    fail "\${var:?error} shows error when unset" "error message" "$result"
 +fi
++
 +# =====================================
 +section "404. PARAMETER EXPANSION ${#var}"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "11" ]; then
 +    pass "\${#var} string with space"
 +else
 +    fail "\${#var} string with space" "11" "$result"
 +fi
++
 +# =====================================
 +section "405. PARAMETER EXPANSION ${var%pattern}"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "file" ]; then
 +    pass "\${var%%.*} removes all extensions"
 +else
 +    fail "\${var%%.*} removes all extensions" "file" "$result"
 +fi
++
 +# =====================================
 +section "406. PARAMETER EXPANSION ${var#pattern}"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "name" ]; then
 +    pass "\${var#prefix} removes literal prefix"
 +else
 +    fail "\${var#prefix} removes literal prefix" "name" "$result"
 +fi
++
 +# =====================================
 +section "407. BACKTICK COMMAND SUBSTITUTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "nested" ]; then
 +    pass "Nested backtick substitution"
 +else
 +    fail "Nested backtick substitution" "nested" "$result"
 +fi
++
 +# =====================================
 +section "408. COMMAND SUBSTITUTION EDGE CASES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "nested" ]; then
 +    pass "Nested \$(...) substitution"
 +else
 +    fail "Nested \$(...) substitution" "nested" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=$(cat <<EOF
 +multi
 +line
 +EOF
 +); echo "$x"' 2>&1)
 +expected=$(printf "multi\nline")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$(...) with here-document inside"
 +else
 +    fail "\$(...) with here-document inside" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "409. ARITHMETIC EXPANSION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "7" ]; then
 +    pass "\$((...)) subtraction"
 +else
 +    fail "\$((...)) subtraction" "7" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "5" ]; then
 +    pass "\$((...)) division"
 +else
 +    fail "\$((...)) division" "5" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "10" ]; then
 +    pass "\$((...)) with \$variable"
 +else
 +    fail "\$((...)) with \$variable" "10" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "-2" ]; then
 +    pass "\$((...)) negative numbers"
 +else
 +    fail "\$((...)) negative numbers" "-2" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "1" ]; then
 +    pass "\$((...)) equality"
 +else
 +    fail "\$((...)) equality" "1" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "1" ]; then
 +    pass "\$((...)) logical AND"
 +else
 +    fail "\$((...)) logical AND" "1" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "1" ]; then
 +    pass "\$((...)) logical OR"
 +else
 +    fail "\$((...)) logical OR" "1" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "1" ]; then
 +    pass "\$((...)) bitwise AND"
 +else
 +    fail "\$((...)) bitwise AND" "1" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "6" ]; then
 +    pass "\$((...)) bitwise XOR"
 +else
 +    fail "\$((...)) bitwise XOR" "6" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +expected=$(printf "8\n8")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$((...)) += assignment"
 +else
 +    fail "\$((...)) += assignment" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=10; echo $((x -= 3)); echo $x' 2>&1)
 +expected=$(printf "7\n7")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$((...)) -= assignment"
 +else
 +    fail "\$((...)) -= assignment" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +expected=$(printf "6\n6")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$((...)) pre-increment"
 +else
 +    fail "\$((...)) pre-increment" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=5; echo $((x++)); echo $x' 2>&1)
 +expected=$(printf "5\n6")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$((...)) post-increment"
 +else
 +    fail "\$((...)) post-increment" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=5; echo $((--x)); echo $x' 2>&1)
 +expected=$(printf "4\n4")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$((...)) pre-decrement"
 +else
 +    fail "\$((...)) pre-decrement" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'x=5; echo $((x--)); echo $x' 2>&1)
 +expected=$(printf "5\n4")
 +if [ "$result" = "$expected" ]; then
 +    pass "\$((...)) post-decrement"
 +else
 +    fail "\$((...)) post-decrement" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "8" ]; then
 +    pass "\$((...)) multiple variables"
 +else
 +    fail "\$((...)) multiple variables" "8" "$result"
 +fi
++
 +# =====================================
 +section "410. TILDE EXPANSION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "$HOME" ]; then
 +    pass "~ in assignment expands"
 +else
 +    fail "~ in assignment expands" "$HOME" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Here-Document and Expansion Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_jobcontrol.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance - Job Control Tests
 +# =====================================
 +# Tests for POSIX job control features (jobs, fg, bg, job specs)
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-jobcontrol]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "146. BASIC JOB CONTROL"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Test that command succeeds
 +test_succeeds() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    if FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "should succeed" "failed"
 +    fi
 +}
++
 +# Test that command produces expected output
 +test_output() {
 +    test_name="$1"
 +    test_cmd="$2"
 +    expected="$3"
++
 +    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    if [ "$output" = "$expected" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$expected" "$output"
 +    fi
 +}
++
 +# Test that output contains pattern
 +test_contains() {
 +    test_name="$1"
 +    test_cmd="$2"
 +    pattern="$3"
++
 +    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    if echo "$output" | grep -q "$pattern"; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "output containing '$pattern'" "$output"
 +    fi
 +}
++
 +# =====================================
 +# TESTS START HERE
 +# =====================================
++
 +section "146. BASIC JOB CONTROL"
++
 +# Note: Many job control features require interactive mode
 +# We test what we can in non-interactive mode
++
 +test_succeeds "jobs builtin exists" 'jobs >/dev/null 2>&1 || true'
 +test_succeeds "bg builtin exists" 'bg 2>/dev/null || true'
 +test_succeeds "fg builtin exists" 'fg 2>/dev/null || true'
++
 +section "147. BACKGROUND JOBS"
++
 +test_succeeds "simple background job" 'sleep 0.1 &'
 +test_succeeds "background with wait" 'sleep 0.1 & wait'
 +test_output "background job count" 'sleep 0.2 & sleep 0.2 & jobs | wc -l | tr -d " "' '2'
 +test_succeeds "wait for specific job" 'sleep 0.1 & PID=$!; wait $PID'
++
 +section "148. JOB EXIT STATUS"
++
 +test_output "background true exit" 'true & wait $!; echo $?' '0'
 +test_output "background false exit" 'false & wait $!; echo $?' '1'
 +test_output "wait preserves status" 'sh -c "exit 42" & wait $!; echo $?' '42'
++
 +section "149. JOBS BUILTIN OUTPUT"
++
 +test_succeeds "jobs with no jobs" 'jobs'
 +test_succeeds "jobs after background" 'sleep 0.5 & jobs; wait'
 +# Test that jobs shows running processes
 +test_contains "jobs shows running" 'sleep 0.5 & jobs' 'sleep'
++
 +section "150. BACKGROUND PIPELINES"
++
 +test_succeeds "pipeline in background" 'echo test | cat &'
 +test_succeeds "multi-stage background pipeline" 'echo test | cat | cat & wait'
 +# Pipeline output appears before exit status since it runs in background
 +test_output "background pipeline exit" 'true | cat & wait $!; echo $?' '0'
++
 +section "151. $! LAST BACKGROUND PID"
++
 +test_succeeds "$! is set after background" 'sleep 0.1 & test -n "$!"'
 +# Use test -gt to check numeric - pattern [!0-9] has portability issues
 +test_succeeds "$! is numeric" 'sleep 0.1 & test "$!" -gt 0'
 +test_succeeds "wait for $!" 'sleep 0.1 & wait $!'
++
 +section "152. JOB SPECIFICATIONS (if supported)"
++
 +# These may not work in non-interactive mode, so we're lenient
 +skip "job spec %1 (interactive feature)"
 +skip "job spec %% (interactive feature)"
 +skip "job spec %+ (interactive feature)"
 +skip "job spec %- (interactive feature)"
++
 +section "153. FG/BG WITH SUSPENDED JOBS"
++
 +# Suspending jobs requires interactive terminal (Ctrl-Z)
 +skip "fg with suspended job (requires interactive tty)"
 +skip "bg with suspended job (requires interactive tty)"
++
 +section "154. WAIT EDGE CASES"
++
 +test_output "wait with no args" 'sleep 0.1 & sleep 0.1 & wait; echo done' 'done'
 +test_output "wait nonexistent PID" 'wait 999999 2>&1 | grep -q "not found\|No such" && echo error || echo ok' 'error'
 +test_succeeds "multiple waits" 'sleep 0.1 & P1=$!; sleep 0.1 & P2=$!; wait $P1; wait $P2'
++
 +section "155. SET -m MONITOR MODE"
++
 +test_succeeds "set -m enables" 'set -m'
 +test_succeeds "set +m disables" 'set -m; set +m'
 +test_output "monitor doesn't affect output" 'set -m; echo test; set +m' 'test'
++
 +section "156. JOB CONTROL WITH FUNCTIONS"
++
 +test_succeeds "background function" 'f() { echo test; }; f &'
 +test_output "wait for function" 'f() { echo ok; }; f & wait; echo done' 'ok
 +done'
++
 +section "157. DISOWN (if implemented)"
++
 +# disown is not strictly POSIX but common
 +skip "disown builtin (not required by POSIX)"
++
 +section "158. AMPERSAND SEMANTICS"
++
 +# Background jobs still output to stdout - just test it succeeds
 +test_succeeds "& at end" 'echo test &'
 +# Background output order is nondeterministic; check all values are present
 +test_output_unordered() {
 +    test_name="$1"
 +    test_cmd="$2"
 +    shift 2
++
 +    output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    for word in "$@"; do
 +        if ! echo "$output" | grep -qF "$word"; then
 +            fail "$test_name" "output containing '$word'" "$output"
 +            return
 +        fi
 +    done
 +    pass "$test_name"
 +}
 +test_output_unordered "multiple & commands" 'echo a & echo b & wait; echo done' a b done
++
 +section "159. BACKGROUND SUBSHELLS"
++
 +test_succeeds "subshell in background" '(sleep 0.1) &'
 +test_output "background subshell isolation" 'VAR=outer; (VAR=inner) & wait; echo $VAR' 'outer'
++
 +section "160. JOB CONTROL ERROR CASES"
++
 +# Test error messages for invalid job control operations
 +test_contains "fg with no jobs" 'fg 2>&1' 'no.*job\|No current job'
 +test_contains "bg with no jobs" 'bg 2>&1' 'no.*job\|No current job'
++
 +# =====================================
 +# SUMMARY
 +# =====================================
++
 +printf "\n==========================================\n"
 +printf "JOB CONTROL TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +# Calculate pass rate (excluding skipped)
 +if [ "$((PASSED + FAILED))" -gt 0 ]; then
 +    pass_rate=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%% (excluding skipped)\n" "$pass_rate"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL NON-SKIPPED JOB CONTROL TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_compliance_options.shadded

1248 lines changed — click to load

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Shell Options and Read Builtin Test Suite for fortsh
 +# =====================================
 +# Tests set options and read builtin per IEEE Std 1003.1-2017
 +# Section: Shell Command Language - set, read
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-options]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# =====================================
 +section "381. SET -e (ERREXIT)"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +if [ "$result" = "reached" ]; then
 +    pass "set -e ignores negated false"
 +else
 +    fail "set -e ignores negated false" "reached" "$result"
 +fi
++
 +# =====================================
 +section "382. SET -u (NOUNSET)"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +exit_code=$?
 +if echo "$result" | grep -qi "unbound\|unset\|error" || [ $exit_code -ne 0 ]; then
 +    pass "set -u errors on unset variable"
 +else
 +    fail "set -u errors on unset variable" "error message" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'set -u; echo ${UNSET_VAR_12345:-default}' 2>&1)
 +if [ "$result" = "default" ]; then
 +    pass "set -u allows default expansion"
 +else
 +    fail "set -u allows default expansion" "default" "$result"
 +fi
++
 +# =====================================
 +section "383. SET -f (NOGLOB)"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" != "[a-z]*" ] && [ -n "$result" ]; then
 +    pass "set +f re-enables globbing"
 +else
 +    fail "set +f re-enables globbing" "(expanded)" "$result"
 +fi
++
 +# =====================================
 +section "384. SET -n (NOEXEC)"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'set -n; echo hello' 2>&1)
 +if [ -z "$result" ]; then
 +    pass "set -n prevents execution"
 +else
 +    fail "set -n prevents execution" "(empty)" "$result"
 +fi
++
 +# =====================================
 +section "385. SET -x (XTRACE)"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -qE "x=5|echo 5|\+ echo"; then
 +    pass "set -x traces variable assignment"
 +else
 +    fail "set -x traces variable assignment" "trace lines" "$result"
 +fi
++
 +# =====================================
 +section "386. SET -v (VERBOSE)"
 +# =====================================
++
 +# 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
 +fortsh_exit=$?
 +"$BASH_REF" -c 'set -v; echo hello' >/dev/null 2>&1
 +bash_exit=$?
 +if [ "$fortsh_exit" -eq "$bash_exit" ]; then
 +    pass "set -v runs without error"
 +else
 +    fail "set -v runs without error" "exit=$bash_exit" "exit=$fortsh_exit"
 +fi
++
 +# =====================================
 +section "387. SET -C (NOCLOBBER)"
 +# =====================================
++
 +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)
 +if echo "$result" | grep -qi "exist\|cannot\|error\|clobber"; then
 +    pass "set -C prevents clobbering existing file"
 +else
 +    # Check if file still has original content
 +    if [ -f "$TEST_DIR/clobber1" ]; then
 +        content=$(cat "$TEST_DIR/clobber1")
 +        if [ "$content" = "test" ]; then
 +            pass "set -C prevents clobbering existing file"
 +        else
 +            fail "set -C prevents clobbering existing file" "error or original content" "$result"
 +        fi
 +    else
 +        fail "set -C prevents clobbering existing file" "error message" "$result"
 +    fi
 +fi
++
 +rm -rf "$TEST_DIR"
++
 +# =====================================
 +section "388. SET -o OPTIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "val" ]; then
 +    pass "set -o nounset (same as -u)"
 +else
 +    fail "set -o nounset (same as -u)" "val" "$result"
 +fi
++
 +# =====================================
 +section "389. SET -- POSITIONAL PARAMETERS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "a b" ]; then
 +    pass "set -- preserves quoted args"
 +else
 +    fail "set -- preserves quoted args" "a b" "$result"
 +fi
++
 +# =====================================
 +section "390. READ BUILTIN BASIC"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "one|two three four" ]; then
 +    pass "read remaining into last variable"
 +else
 +    fail "read remaining into last variable" "one|two three four" "$result"
 +fi
++
 +# =====================================
 +section "391. READ WITH IFS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = ">a|b<" ]; then
 +    pass "read strips leading/trailing whitespace"
 +else
 +    fail "read strips leading/trailing whitespace" ">a|b<" "$result"
 +fi
++
 +# =====================================
 +section "392. READ -r (RAW MODE)"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo "hello\\nworld" | { read -r x; echo "$x"; }' 2>&1)
 +if [ "$result" = 'hello\nworld' ]; then
 +    pass "read -r preserves backslashes"
 +else
 +    fail "read -r preserves backslashes" 'hello\nworld' "$result"
 +fi
++
 +# 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)
 +if [ "$result" = "linecontinued" ]; then
 +    pass "read without -r joins continued lines"
 +else
 +    fail "read without -r joins continued lines" "linecontinued" "$result"
 +fi
++
 +# =====================================
 +section "393. READ EXIT STATUS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "1" ]; then
 +    pass "read returns non-zero on EOF"
 +else
 +    fail "read returns non-zero on EOF" "1" "$result"
 +fi
++
 +# =====================================
 +section "394. SHIFT BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "1" ]; then
 +    pass "shift beyond count returns error"
 +else
 +    fail "shift beyond count returns error" "1" "$result"
 +fi
++
 +# =====================================
 +section "395. SPECIAL PARAMETERS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +expected=$(printf "[a]\n[b]\n[c]")
 +if [ "$result" = "$expected" ]; then
 +    pass "\"\$@\" preserves separate arguments"
 +else
 +    fail "\"\$@\" preserves separate arguments" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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"
 +else
 +    fail "\"\$@\" preserves quoted arguments" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "0" ]; then
 +    pass "\$? returns exit status"
 +else
 +    fail "\$? returns exit status" "0" "$result"
 +fi
++
 +# =====================================
 +section "396. IFS WORD SPLITTING"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    fail "IFS changes word splitting" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +if [ "$result" = "a b c" ]; then
 +    pass "IFS with multiple characters"
 +else
 +    fail "IFS with multiple characters" "a b c" "$result"
 +fi
++
 +# =====================================
 +section "397. ALIAS BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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
 +    fail "alias defines and shows alias" "ls -la" "$result"
 +fi
++
 +# 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)
 +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)
 +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)
 +if echo "$result" | grep -qE "127|1"; then
 +    pass "unalias removes alias"
 +else
 +    fail "unalias removes alias" "non-zero exit" "$result"
 +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)
 +if echo "$result" | grep -q "echo two"; then
 +    pass "alias can be redefined"
 +else
 +    fail "alias can be redefined" "echo two" "$result"
 +fi
++
 +# =====================================
 +section "398. EXPORT BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "value" ]; then
 +    pass "exported var visible in subshell"
 +else
 +    fail "exported var visible in subshell" "value" "$result"
 +fi
++
 +# =====================================
 +section "399. READONLY BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "1 2" ]; then
 +    pass "readonly multiple variables"
 +else
 +    fail "readonly multiple variables" "1 2" "$result"
 +fi
++
 +# =====================================
 +section "400. UNSET BUILTIN"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if echo "$result" | grep -qE "1|127"; then
 +    pass "unset -f removes function"
 +else
 +    fail "unset -f removes function" "non-zero exit" "$result"
 +fi
++
 +# =====================================
 +section "401. GETOPTS BUILTIN"
 +# =====================================
++
 +# Basic option parsing
 +result=$("$FORTSH_BIN" -c 'set -- -a; getopts "ab" opt; echo $opt' 2>&1)
 +if [ "$result" = "a" ]; then
 +    pass "getopts parses simple option"
 +else
 +    fail "getopts parses simple option" "a" "$result"
 +fi
++
 +# Option with argument
 +result=$("$FORTSH_BIN" -c 'set -- -a value; getopts "a:" opt; echo "$OPTARG"' 2>&1)
 +if [ "$result" = "value" ]; then
 +    pass "getopts sets OPTARG"
 +else
 +    fail "getopts sets OPTARG" "value" "$result"
 +fi
++
 +# OPTIND increment
 +result=$("$FORTSH_BIN" -c 'set -- -a -b; getopts "ab" opt; getopts "ab" opt; echo $OPTIND' 2>&1)
 +if [ "$result" = "3" ]; then
 +    pass "getopts increments OPTIND"
 +else
 +    fail "getopts increments OPTIND" "3" "$result"
 +fi
++
 +# Multiple options in loop
 +result=$("$FORTSH_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
 +    fail "getopts in while loop" "abc" "$result"
 +fi
++
 +# Invalid option handling
 +result=$("$FORTSH_BIN" -c 'set -- -z; getopts "ab" opt 2>/dev/null; echo $opt' 2>&1)
 +if [ "$result" = "?" ]; then
 +    pass "getopts returns ? for invalid option"
 +else
 +    fail "getopts returns ? for invalid option" "?" "$result"
 +fi
++
 +# Silent mode with leading colon
 +result=$("$FORTSH_BIN" -c 'set -- -a; getopts ":a:b" opt; echo $opt' 2>&1)
 +if [ "$result" = ":" ] || [ "$result" = "a" ]; then
 +    pass "getopts silent mode with colon"
 +else
 +    fail "getopts silent mode with colon" ": or a" "$result"
 +fi
++
 +# Reset OPTIND
 +result=$("$FORTSH_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
 +    fail "OPTIND reset allows reparse" "a" "$result"
 +fi
++
 +# =====================================
 +section "402. TYPE BUILTIN"
 +# =====================================
++
 +# type finds commands
 +result=$("$FORTSH_BIN" -c 'type echo' 2>&1)
 +if echo "$result" | grep -qE "echo|builtin|/"; then
 +    pass "type finds echo"
 +else
 +    fail "type finds echo" "echo info" "$result"
 +fi
++
 +# type returns error for unknown
 +result=$("$FORTSH_BIN" -c 'type nonexistent_xyz_cmd 2>/dev/null; echo $?' 2>&1)
 +if [ "$result" != "0" ]; then
 +    pass "type returns error for unknown command"
 +else
 +    fail "type returns error for unknown command" "non-zero" "$result"
 +fi
++
 +# type finds functions
 +result=$("$FORTSH_BIN" -c 'myfunc() { :; }; type myfunc' 2>&1)
 +if echo "$result" | grep -qE "myfunc|function"; then
 +    pass "type finds functions"
 +else
 +    fail "type finds functions" "function info" "$result"
 +fi
++
 +# type finds aliases
 +result=$("$FORTSH_BIN" -c 'alias myalias=echo; type myalias' 2>&1)
 +if echo "$result" | grep -qE "myalias|alias"; then
 +    pass "type finds aliases"
 +else
 +    fail "type finds aliases" "alias info" "$result"
 +fi
++
 +# type finds builtins
 +result=$("$FORTSH_BIN" -c 'type cd' 2>&1)
 +if echo "$result" | grep -qE "cd|builtin"; then
 +    pass "type identifies builtins"
 +else
 +    fail "type identifies builtins" "builtin info" "$result"
 +fi
++
 +# =====================================
 +section "403. COMMAND BUILTIN"
 +# =====================================
++
 +# command -v finds commands
 +result=$("$FORTSH_BIN" -c 'command -v echo' 2>&1)
 +if [ -n "$result" ]; then
 +    pass "command -v finds echo"
 +else
 +    fail "command -v finds echo" "non-empty" "$result"
 +fi
++
 +# command -v returns empty for unknown
 +result=$("$FORTSH_BIN" -c 'command -v nonexistent_xyz_cmd; echo $?' 2>&1)
 +if [ "$result" != "0" ]; then
 +    pass "command -v returns error for unknown"
 +else
 +    fail "command -v returns error for unknown" "non-zero exit" "$result"
 +fi
++
 +# command bypasses functions
 +result=$("$FORTSH_BIN" -c 'echo() { printf "FUNC"; }; command echo hello' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "command bypasses function"
 +else
 +    fail "command bypasses function" "hello" "$result"
 +fi
++
 +# command bypasses aliases
 +result=$("$FORTSH_BIN" -c 'alias echo="printf ALIAS"; command echo hello' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "command bypasses alias"
 +else
 +    fail "command bypasses alias" "hello" "$result"
 +fi
++
 +# =====================================
 +section "404. TRAP BUILTIN EDGE CASES"
 +# =====================================
++
 +# trap with empty action
 +result=$("$FORTSH_BIN" -c 'trap "" INT; trap' 2>&1)
 +if echo "$result" | grep -qE "INT|''"; then
 +    pass "trap with empty action (ignore signal)"
 +else
 +    fail "trap with empty action (ignore signal)" "INT trap" "$result"
 +fi
++
 +# trap - removes trap
 +result=$("$FORTSH_BIN" -c 'trap "echo x" EXIT; trap - EXIT; trap' 2>&1)
 +if ! echo "$result" | grep -q "EXIT"; then
 +    pass "trap - removes trap"
 +else
 +    fail "trap - removes trap" "no EXIT" "$result"
 +fi
++
 +# Multiple traps
 +result=$("$FORTSH_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
 +    fail "Multiple traps can be set" ">=2 lines" "$result"
 +fi
++
 +# trap with no args lists traps
 +result=$("$FORTSH_BIN" -c 'trap "echo x" INT; trap' 2>&1)
 +if [ -n "$result" ]; then
 +    pass "trap with no args lists traps"
 +else
 +    fail "trap with no args lists traps" "non-empty" "$result"
 +fi
++
 +# EXIT trap runs on exit
 +result=$("$FORTSH_BIN" -c 'trap "echo EXITING" EXIT; exit 0' 2>&1)
 +if [ "$result" = "EXITING" ]; then
 +    pass "EXIT trap executes on exit"
 +else
 +    fail "EXIT trap executes on exit" "EXITING" "$result"
 +fi
++
 +# =====================================
 +section "405. HASH BUILTIN"
 +# =====================================
++
 +# hash without args
 +result=$("$FORTSH_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)
 +if [ "$result" = "0" ]; then
 +    pass "hash -r clears cache"
 +else
 +    fail "hash -r clears cache" "0" "$result"
 +fi
++
 +# =====================================
 +section "406. WAIT BUILTIN EDGE CASES"
 +# =====================================
++
 +# wait with no args
 +result=$("$FORTSH_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
 +    fail "wait with no args waits for all" "done" "$result"
 +fi
++
 +# wait with specific PID
 +result=$("$FORTSH_BIN" -c 'sleep 0.1 & pid=$!; wait $pid; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass "wait with PID"
 +else
 +    fail "wait with PID" "0" "$result"
 +fi
++
 +# wait preserves exit status
 +result=$("$FORTSH_BIN" -c '(exit 42) & pid=$!; wait $pid; echo $?' 2>&1)
 +if [ "$result" = "42" ]; then
 +    pass "wait preserves exit status"
 +else
 +    fail "wait preserves exit status" "42" "$result"
 +fi
++
 +# =====================================
 +section "407. ULIMIT BUILTIN"
 +# =====================================
++
 +# ulimit -a shows limits
 +result=$("$FORTSH_BIN" -c 'ulimit -a 2>&1' | head -5)
 +if [ -n "$result" ]; then
 +    pass "ulimit -a shows limits"
 +else
 +    fail "ulimit -a shows limits" "non-empty" "$result"
 +fi
++
 +# ulimit shows soft limit
 +result=$("$FORTSH_BIN" -c 'ulimit 2>&1' | head -1)
 +if [ -n "$result" ]; then
 +    pass "ulimit shows default limit"
 +else
 +    fail "ulimit shows default limit" "non-empty" "$result"
 +fi
++
 +# =====================================
 +section "408. READ BUILTIN"
 +# =====================================
++
 +# read single variable
 +result=$("$FORTSH_BIN" -c 'echo "hello" | { read x; echo $x; }' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "read single variable"
 +else
 +    fail "read single variable" "hello" "$result"
 +fi
++
 +# read multiple variables
 +result=$("$FORTSH_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
 +    fail "read multiple variables" "a:b:c" "$result"
 +fi
++
 +# read with extra words
 +result=$("$FORTSH_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
 +    fail "read extra words to last var" "a|b c d e" "$result"
 +fi
++
 +# =====================================
 +section "409. PRINTF BUILTIN"
 +# =====================================
++
 +# printf basic
 +result=$("$FORTSH_BIN" -c 'printf "hello\n"' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "printf basic"
 +else
 +    fail "printf basic" "hello" "$result"
 +fi
++
 +# printf with format
 +result=$("$FORTSH_BIN" -c 'printf "%s world\n" "hello"' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "printf with %s"
 +else
 +    fail "printf with %s" "hello world" "$result"
 +fi
++
 +# printf with number
 +result=$("$FORTSH_BIN" -c 'printf "%d\n" 42' 2>&1)
 +if [ "$result" = "42" ]; then
 +    pass "printf with %d"
 +else
 +    fail "printf with %d" "42" "$result"
 +fi
++
 +# printf width
 +result=$("$FORTSH_BIN" -c 'printf "%5d\n" 42' 2>&1)
 +if [ "$result" = "   42" ]; then
 +    pass "printf with width"
 +else
 +    fail "printf with width" "   42" "$result"
 +fi
++
 +# =====================================
 +section "410. ECHO BUILTIN"
 +# =====================================
++
 +# echo basic
 +result=$("$FORTSH_BIN" -c 'echo hello' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "echo basic"
 +else
 +    fail "echo basic" "hello" "$result"
 +fi
++
 +# echo multiple args
 +result=$("$FORTSH_BIN" -c 'echo a b c' 2>&1)
 +if [ "$result" = "a b c" ]; then
 +    pass "echo multiple args"
 +else
 +    fail "echo multiple args" "a b c" "$result"
 +fi
++
 +# echo with quotes
 +result=$("$FORTSH_BIN" -c 'echo "hello world"' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "echo with quotes"
 +else
 +    fail "echo with quotes" "hello world" "$result"
 +fi
++
 +# =====================================
 +section "411. KILL BUILTIN"
 +# =====================================
++
 +# kill -l lists signals
 +result=$("$FORTSH_BIN" -c 'kill -l 2>&1 | head -1')
 +if [ -n "$result" ]; then
 +    pass "kill -l lists signals"
 +else
 +    fail "kill -l lists signals" "non-empty" "$result"
 +fi
++
 +# =====================================
 +section "412. SET OPTIONS"
 +# =====================================
++
 +# set -e (errexit)
 +result=$("$FORTSH_BIN" -c 'set -e; true; echo reached' 2>&1)
 +if [ "$result" = "reached" ]; then
 +    pass "set -e continues on success"
 +else
 +    fail "set -e continues on success" "reached" "$result"
 +fi
++
 +# set -x (xtrace)
 +result=$("$FORTSH_BIN" -c 'set -x; echo test 2>&1' | grep -c test)
 +if [ "$result" -ge 1 ]; then
 +    pass "set -x traces commands"
 +else
 +    fail "set -x traces commands"
 +fi
++
 +# set -f (noglob)
 +result=$("$FORTSH_BIN" -c 'set -f; echo *' 2>&1)
 +if [ "$result" = "*" ]; then
 +    pass "set -f disables glob"
 +else
 +    fail "set -f disables glob" "*" "$result"
 +fi
++
 +# set +f (enable glob)
 +result=$("$FORTSH_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
 +    fail "set +f enables glob"
 +fi
++
 +# =====================================
 +section "413. UNSET BUILTIN"
 +# =====================================
++
 +# unset variable
 +result=$("$FORTSH_BIN" -c 'x=value; unset x; echo ${x:-empty}' 2>&1)
 +if [ "$result" = "empty" ]; then
 +    pass "unset removes variable"
 +else
 +    fail "unset removes variable" "empty" "$result"
 +fi
++
 +# unset function
 +result=$("$FORTSH_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
 +    fail "unset -f removes function" "gone" "$result"
 +fi
++
 +# unset readonly fails
 +result=$("$FORTSH_BIN" -c 'readonly x=1; unset x 2>/dev/null; echo $?' 2>&1)
 +if [ "$result" != "0" ]; then
 +    pass "unset readonly fails"
 +else
 +    fail "unset readonly fails" "non-zero" "$result"
 +fi
++
 +# =====================================
 +section "414. SHIFT BUILTIN"
 +# =====================================
++
 +# basic shift
 +result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $1' 2>&1)
 +if [ "$result" = "b" ]; then
 +    pass "shift removes first arg"
 +else
 +    fail "shift removes first arg" "b" "$result"
 +fi
++
 +# shift with count
 +result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 3; echo $1' 2>&1)
 +if [ "$result" = "d" ]; then
 +    pass "shift with count"
 +else
 +    fail "shift with count" "d" "$result"
 +fi
++
 +# shift updates $#
 +result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $#' 2>&1)
 +if [ "$result" = "2" ]; then
 +    pass "shift updates arg count"
 +else
 +    fail "shift updates arg count" "2" "$result"
 +fi
++
 +# =====================================
 +section "415. TRUE AND FALSE BUILTINS"
 +# =====================================
++
 +# true returns 0
 +result=$("$FORTSH_BIN" -c 'true; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass "true returns 0"
 +else
 +    fail "true returns 0" "0" "$result"
 +fi
++
 +# false returns 1
 +result=$("$FORTSH_BIN" -c 'false; echo $?' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "false returns 1"
 +else
 +    fail "false returns 1" "1" "$result"
 +fi
++
 +# true in conditional
 +result=$("$FORTSH_BIN" -c 'if true; then echo yes; fi' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "true in if condition"
 +else
 +    fail "true in if condition" "yes" "$result"
 +fi
++
 +# false in conditional
 +result=$("$FORTSH_BIN" -c 'if false; then echo no; else echo yes; fi' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass "false in if condition"
 +else
 +    fail "false in if condition" "yes" "$result"
 +fi
++
 +# =====================================
 +section "416. COLON BUILTIN"
 +# =====================================
++
 +# colon returns 0
 +result=$("$FORTSH_BIN" -c ':; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass "colon returns 0"
 +else
 +    fail "colon returns 0" "0" "$result"
 +fi
++
 +# colon with args (ignored)
 +result=$("$FORTSH_BIN" -c ': arg1 arg2 arg3; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass "colon ignores args"
 +else
 +    fail "colon ignores args" "0" "$result"
 +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)
 +if [ "$result" = "3" ]; then
 +    pass "colon as infinite loop condition"
 +else
 +    fail "colon as infinite loop condition" "3" "$result"
 +fi
++
 +# =====================================
 +section "417. PWD BUILTIN"
 +# =====================================
++
 +# pwd returns current dir
 +result=$("$FORTSH_BIN" -c 'pwd | grep -c "^/"' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "pwd returns absolute path"
 +else
 +    fail "pwd returns absolute path" "1" "$result"
 +fi
++
 +# pwd after cd
 +result=$("$FORTSH_BIN" -c 'cd /tmp && pwd' 2>&1)
 +if [ "$result" = "/tmp" ]; then
 +    pass "pwd after cd"
 +else
 +    fail "pwd after cd" "/tmp" "$result"
 +fi
++
 +# =====================================
 +section "418. CD BUILTIN"
 +# =====================================
++
 +# cd to absolute path
 +result=$("$FORTSH_BIN" -c 'cd /tmp && pwd' 2>&1)
 +if [ "$result" = "/tmp" ]; then
 +    pass "cd to absolute path"
 +else
 +    fail "cd to absolute path" "/tmp" "$result"
 +fi
++
 +# cd - returns to OLDPWD
 +result=$("$FORTSH_BIN" -c 'cd /tmp; cd /; cd - 2>&1' 2>&1)
 +if echo "$result" | grep -q "tmp"; then
 +    pass "cd - returns to OLDPWD"
 +else
 +    fail "cd - returns to OLDPWD"
 +fi
++
 +# cd nonexistent fails
 +result=$("$FORTSH_BIN" -c 'cd /nonexistent_dir_xyz 2>/dev/null; echo $?' 2>&1)
 +if [ "$result" != "0" ]; then
 +    pass "cd nonexistent fails"
 +else
 +    fail "cd nonexistent fails" "non-zero" "$result"
 +fi
++
 +# =====================================
 +section "419. TIMES BUILTIN"
 +# =====================================
++
 +# times outputs something
 +result=$("$FORTSH_BIN" -c 'times 2>&1 | head -1 || echo skipped')
 +if [ -n "$result" ]; then
 +    pass "times outputs timing info"
 +else
 +    fail "times outputs timing info" "non-empty" "$result"
 +fi
++
 +# =====================================
 +section "420. EXIT BUILTIN"
 +# =====================================
++
 +# exit with code
 +result=$("$FORTSH_BIN" -c 'exit 42' 2>&1; echo $?)
 +if [ "$result" = "42" ]; then
 +    pass "exit with code"
 +else
 +    fail "exit with code" "42" "$result"
 +fi
++
 +# exit default 0
 +result=$("$FORTSH_BIN" -c 'exit' 2>&1; echo $?)
 +if [ "$result" = "0" ]; then
 +    pass "exit default 0"
 +else
 +    fail "exit default 0" "0" "$result"
 +fi
++
 +# exit from subshell
 +result=$("$FORTSH_BIN" -c '(exit 7); echo $?' 2>&1)
 +if [ "$result" = "7" ]; then
 +    pass "exit from subshell"
 +else
 +    fail "exit from subshell" "7" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Shell Options and Read Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_printf.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance printf Builtin Test Suite for fortsh
 +# =====================================
 +# Tests the printf builtin command per IEEE Std 1003.1-2017
 +# Section: Shell & Utilities - printf
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-printf]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# =====================================
 +section "358. PRINTF BASIC STRING FORMAT %s"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "hi        |" ]; then
 +    pass "printf %-10s width left-align"
 +else
 +    fail "printf %-10s width left-align" "hi        |" "$result"
 +fi
++
 +# =====================================
 +section "359. PRINTF INTEGER FORMATS %d %i"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "+42" ]; then
 +    pass "printf %+d explicit plus sign"
 +else
 +    fail "printf %+d explicit plus sign" "+42" "$result"
 +fi
++
 +# =====================================
 +section "360. PRINTF OCTAL AND HEX FORMATS %o %x %X"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +if [ "$result" = "010" ]; then
 +    pass "printf %#o alternate octal form"
 +else
 +    fail "printf %#o alternate octal form" "010" "$result"
 +fi
++
 +# =====================================
 +section "361. PRINTF CHARACTER FORMAT %c"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "abc" ]; then
 +    pass "printf %c multiple chars"
 +else
 +    fail "printf %c multiple chars" "abc" "$result"
 +fi
++
 +# =====================================
 +section "362. PRINTF ESCAPE SEQUENCES"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'printf "hello\nworld\n"' 2>&1)
 +expected=$(printf "hello\nworld")
 +if [ "$result" = "$expected" ]; then
 +    pass "printf \\n newline"
 +else
 +    fail "printf \\n newline" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'printf "a\tb\n"' 2>&1)
 +expected=$(printf "a\tb")
 +if [ "$result" = "$expected" ]; then
 +    pass "printf \\t tab"
 +else
 +    fail "printf \\t tab" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "A" ]; then
 +    pass "printf \\NNN octal escape"
 +else
 +    fail "printf \\NNN octal escape" "A" "$result"
 +fi
++
 +# =====================================
 +section "363. PRINTF %b ESCAPE INTERPRETATION"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'printf "%b\n" "hello\nworld"' 2>&1)
 +expected=$(printf "hello\nworld")
 +if [ "$result" = "$expected" ]; then
 +    pass "printf %b interprets backslash escapes"
 +else
 +    fail "printf %b interprets backslash escapes" "(newline)" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'printf "%b\n" "tab\there"' 2>&1)
 +expected=$(printf "tab\there")
 +if [ "$result" = "$expected" ]; then
 +    pass "printf %b interprets \\t"
 +else
 +    fail "printf %b interprets \\t" "(tab)" "$result"
 +fi
++
 +# =====================================
 +section "364. PRINTF FORMAT REUSE"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    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)
 +if [ "$result" = "1 2 3 4 5 " ]; then
 +    pass "printf %d reused for multiple integers"
 +else
 +    fail "printf %d reused for multiple integers" "1 2 3 4 5 " "$result"
 +fi
++
 +# =====================================
 +section "365. PRINTF WITH VARIABLES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "name: 42" ]; then
 +    pass "printf format from variable"
 +else
 +    fail "printf format from variable" "name: 42" "$result"
 +fi
++
 +# =====================================
 +section "366. PRINTF DYNAMIC WIDTH AND PRECISION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "       hel" ]; then
 +    pass "printf %*.*s dynamic width and precision"
 +else
 +    fail "printf %*.*s dynamic width and precision" "       hel" "$result"
 +fi
++
 +# =====================================
 +section "367. PRINTF RETURN VALUE"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'printf "%s" "test"; echo $?' 2>&1)
 +if echo "$result" | grep -q "0"; then
 +    pass "printf returns 0 on success"
 +else
 +    fail "printf returns 0 on success" "0" "$result"
 +fi
++
 +# =====================================
 +section "368. PRINTF EDGE CASES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "" ]; then
 +    pass "printf empty argument"
 +else
 +    fail "printf empty argument" "(empty)" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "" ]; then
 +    pass "printf empty format string"
 +else
 +    fail "printf empty format string" "(empty)" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX printf Builtin Test Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_quoting.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Quoting Test Suite for fortsh
 +# =====================================
 +# Tests quoting and escaping per IEEE Std 1003.1-2017
 +# Section: Shell Command Language - Quoting
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-quoting]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# =====================================
 +section "446. SINGLE QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +if [ "$result" = '$(echo no)' ]; then
 +    pass "Single quotes prevent command substitution"
 +else
 +    fail "Single quotes prevent command substitution" '$(echo no)' "$result"
 +fi
++
 +# =====================================
 +section "447. DOUBLE QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = 'dollar$sign' ]; then
 +    pass "Double quotes with escaped dollar"
 +else
 +    fail "Double quotes with escaped dollar" 'dollar$sign' "$result"
 +fi
++
 +# =====================================
 +section "448. BACKSLASH ESCAPING"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = 'back\slash' ]; then
 +    pass "Backslash escapes backslash"
 +else
 +    fail "Backslash escapes backslash" 'back\slash' "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'echo hello\
 +world' 2>&1)
 +if [ "$result" = "helloworld" ]; then
 +    pass "Backslash-newline line continuation"
 +else
 +    fail "Backslash-newline line continuation" "helloworld" "$result"
 +fi
++
 +# =====================================
 +section "449. MIXED QUOTING"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo "hello"'\''world'\''' 2>&1)
 +# Adjacent quoted strings concatenate: "hello" + 'world' = helloworld
 +if [ "$result" = "helloworld" ]; then
 +    pass "Adjacent double and single quotes"
 +else
 +    fail "Adjacent double and single quotes" "helloworld" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "don't" ]; then
 +    pass "Single quote in single quoted string"
 +else
 +    fail "Single quote in single quoted string" "don't" "$result"
 +fi
++
 +# =====================================
 +section "450. QUOTING SPECIAL CHARACTERS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +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)
 +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)
 +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)
 +if [ "$result" = "hash#comment" ]; then
 +    pass "Hash in double quotes"
 +else
 +    fail "Hash in double quotes" "hash#comment" "$result"
 +fi
++
 +# =====================================
 +section "451. EMPTY STRINGS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "a  b" ]; then
 +    pass "Empty string preserves word"
 +else
 +    fail "Empty string preserves word" "a  b" "$result"
 +fi
++
 +# =====================================
 +section "452. WORD SPLITTING"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    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)
 +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)
 +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)
 +if [ "$result" = "a  b" ]; then
 +    pass "Quoting preserves multiple spaces"
 +else
 +    fail "Quoting preserves multiple spaces" "a  b" "$result"
 +fi
++
 +# =====================================
 +section "453. GLOB PREVENTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "?" ]; then
 +    pass "Double quotes prevent ? expansion"
 +else
 +    fail "Double quotes prevent ? expansion" "?" "$result"
 +fi
++
 +# =====================================
 +section "454. QUOTE IN VARIABLE"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = 'has "quotes"' ]; then
 +    pass "Double quotes inside variable"
 +else
 +    fail "Double quotes inside variable" 'has "quotes"' "$result"
 +fi
++
 +# =====================================
 +section "455. QUOTING IN ASSIGNMENTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "with value" ]; then
 +    pass "Variable expansion in assignment"
 +else
 +    fail "Variable expansion in assignment" "with value" "$result"
 +fi
++
 +# =====================================
 +section "456. QUOTING IN COMMAND SUBSTITUTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "nested quotes" ]; then
 +    pass "Nested quotes in command substitution"
 +else
 +    fail "Nested quotes in command substitution" "nested quotes" "$result"
 +fi
++
 +# =====================================
 +section "457. BACKSLASH IN DOUBLE QUOTES"
 +# =====================================
++
 +# 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)
 +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)
 +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)
 +if [ "$result" = 'tab\t' ]; then
 +    pass "Backslash-t in double quotes (literal)"
 +else
 +    fail "Backslash-t in double quotes (literal)" 'tab\t' "$result"
 +fi
++
 +# =====================================
 +section "458. DOLLAR IN QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = 'cost: $5' ]; then
 +    pass "Dollar in single quotes (literal)"
 +else
 +    fail "Dollar in single quotes (literal)" 'cost: $5' "$result"
 +fi
++
 +# =====================================
 +section "459. NEWLINE IN QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo "line1
 +line2"' 2>&1)
 +expected=$(printf "line1\nline2")
 +if [ "$result" = "$expected" ]; then
 +    pass "Literal newline in double quotes"
 +else
 +    fail "Literal newline in double quotes" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c "echo 'line1
 +line2'" 2>&1)
 +expected=$(printf "line1\nline2")
 +if [ "$result" = "$expected" ]; then
 +    pass "Literal newline in single quotes"
 +else
 +    fail "Literal newline in single quotes" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "460. TAB AND SPACE IN QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "  spaces  " ]; then
 +    pass "Multiple spaces in double quotes"
 +else
 +    fail "Multiple spaces in double quotes" "  spaces  " "$result"
 +fi
++
 +# =====================================
 +section "461. QUOTING IN FOR LOOP"
 +# =====================================
++
 +result=$("$FORTSH_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"
 +else
 +    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)
 +expected=$(printf "[a]\n[b]\n[c]")
 +if [ "$result" = "$expected" ]; then
 +    pass "Unquoted var splits in for"
 +else
 +    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)
 +if [ "$result" = "[a b c]" ]; then
 +    pass "Quoted var no split in for"
 +else
 +    fail "Quoted var no split in for" "[a b c]" "$result"
 +fi
++
 +# =====================================
 +section "462. QUOTING IN CASE STATEMENT"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "yes" ]; then
 +    pass "Quoted pattern in case"
 +else
 +    fail "Quoted pattern in case" "yes" "$result"
 +fi
++
 +# =====================================
 +section "463. QUOTING SPECIAL SHELL CHARS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = 'back`tick' ]; then
 +    pass "Backtick in single quotes"
 +else
 +    fail "Backtick in single quotes" 'back`tick' "$result"
 +fi
++
 +# =====================================
 +section "464. QUOTING IN ARITHMETIC"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "8" ]; then
 +    pass "Quoted assignment used in arithmetic"
 +else
 +    fail "Quoted assignment used in arithmetic" "8" "$result"
 +fi
++
 +# =====================================
 +section "465. ESCAPE SEQUENCES"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo "hello\tworld"' 2>&1)
 +if echo "$result" | grep -q "hello"; then
 +    pass "Backslash-t in double quotes"
 +else
 +    fail "Backslash-t in double quotes"
 +fi
++
 +# Test backslash-n literal in single quotes (use double backslash for POSIX sh compatibility)
 +result=$("$FORTSH_BIN" -c "echo 'hello\\nworld'" 2>&1)
 +if printf '%s' "$result" | grep -q 'hello.nworld'; then
 +    pass "Backslash-n literal in single quotes"
 +else
 +    fail "Backslash-n literal in single quotes"
 +fi
++
 +# =====================================
 +section "466. QUOTING AND WORD SPLITTING"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "1" ]; then
 +    pass "Empty quoted var produces one empty arg"
 +else
 +    fail "Empty quoted var produces one empty arg" "1" "$result"
 +fi
++
 +# =====================================
 +section "467. QUOTING SPECIAL PARAMETERS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +expected=$(printf "[a]\n[b c]\n[d]")
 +if [ "$result" = "$expected" ]; then
 +    pass 'Quoted $@ preserves quoting in original args'
 +else
 +    fail 'Quoted $@ preserves quoting in original args'
 +fi
++
 +# =====================================
 +section "468. NESTED QUOTING"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "double 'with' single" ]; then
 +    pass "Single quotes inside double quotes (escaped)"
 +else
 +    fail "Single quotes inside double quotes (escaped)"
 +fi
++
 +# =====================================
 +section "469. QUOTING IN ASSIGNMENTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "hello world" ]; then
 +    pass "Escaped space in assignment"
 +else
 +    fail "Escaped space in assignment" "hello world" "$result"
 +fi
++
 +# =====================================
 +section "470. QUOTING IN COMMAND SUBSTITUTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "hello world" ]; then
 +    pass "Quoted string in backtick substitution"
 +else
 +    fail "Quoted string in backtick substitution" "hello world" "$result"
 +fi
++
 +# =====================================
 +section "471. QUOTING AND GLOB PREVENTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "[abc]" ]; then
 +    pass "Quoted brackets are literal"
 +else
 +    fail "Quoted brackets are literal" "[abc]" "$result"
 +fi
++
 +# =====================================
 +section "472. QUOTING IN TESTS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "match" ]; then
 +    pass "Quoted var with spaces in test ="
 +else
 +    fail "Quoted var with spaces in test =" "match" "$result"
 +fi
++
 +# =====================================
 +section "473. QUOTING IN CASE PATTERNS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "match" ]; then
 +    pass "Quoted pattern with space in case"
 +else
 +    fail "Quoted pattern with space in case" "match" "$result"
 +fi
++
 +# =====================================
 +section "474. QUOTING IN FUNCTION ARGS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "2" ]; then
 +    pass "Quoted args count in function"
 +else
 +    fail "Quoted args count in function" "2" "$result"
 +fi
++
 +# =====================================
 +section "475. DOLLAR IN QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = '$HOME' ]; then
 +    pass "Dollar in single quotes"
 +else
 +    fail "Dollar in single quotes" "\$HOME" "$result"
 +fi
++
 +# =====================================
 +section "476. BACKSLASH IN QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = '\' ]; then
 +    pass "Backslash in single quotes"
 +else
 +    fail "Backslash in single quotes" "\\" "$result"
 +fi
++
 +# =====================================
 +section "477. QUOTE REMOVAL"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "abc" ]; then
 +    pass "Adjacent quoted strings concatenate"
 +else
 +    fail "Adjacent quoted strings concatenate" "abc" "$result"
 +fi
++
 +# =====================================
 +section "478. MIXED QUOTE STYLES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "singledoublesingle" ]; then
 +    pass "Alternating quote styles"
 +else
 +    fail "Alternating quote styles" "singledoublesingle" "$result"
 +fi
++
 +# =====================================
 +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)
 +if [ "$result" = "test" ]; then
 +    pass "Quoted filename with space in redirect"
 +else
 +    fail "Quoted filename with space in redirect" "test" "$result"
 +fi
++
 +# =====================================
 +section "480. EMPTY QUOTES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "[]" ]; then
 +    pass "Empty var in quotes"
 +else
 +    fail "Empty var in quotes" "[]" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Quoting Test Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_redirect.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Redirection and Pipeline Test Suite for fortsh
 +# =====================================
 +# Tests redirections and pipelines per IEEE Std 1003.1-2017
 +# Section: Shell Command Language - Redirection
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-redirect]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +TEST_DIR="/tmp/fortsh_redirect_$$"
 +mkdir -p "$TEST_DIR"
++
 +cleanup() {
 +    rm -rf "$TEST_DIR"
 +}
 +trap cleanup EXIT
++
 +# =====================================
 +section "428. OUTPUT REDIRECTION >"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "multi word" ]; then
 +    pass "> with quoted string"
 +else
 +    fail "> with quoted string" "multi word" "$result"
 +fi
++
 +# =====================================
 +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)
 +expected=$(printf "first\nsecond")
 +if [ "$result" = "$expected" ]; then
 +    pass ">> appends to file"
 +else
 +    fail ">> appends to file" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_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
 +    fail ">> creates file if not exists" "line1" "$result"
 +fi
++
 +# =====================================
 +section "430. INPUT REDIRECTION <"
 +# =====================================
++
 +echo "test input" > "$TEST_DIR/input.txt"
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "test input" ]; then
 +    pass "< with read builtin"
 +else
 +    fail "< with read builtin" "test input" "$result"
 +fi
++
 +# =====================================
 +section "431. STDERR REDIRECTION 2>"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "stdout" ]; then
 +    pass "2>/dev/null suppresses stderr"
 +else
 +    fail "2>/dev/null suppresses stderr" "stdout" "$result"
 +fi
++
 +# =====================================
 +section "432. REDIRECT STDERR TO STDOUT 2>&1"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -qi "no such\|not found\|cannot"; then
 +    pass "2>&1 stderr goes through pipe"
 +else
 +    fail "2>&1 stderr goes through pipe" "error in pipe" "$result"
 +fi
++
 +# =====================================
 +section "433. REDIRECT STDOUT TO STDERR 1>&2"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo error >&2' 2>&1)
 +if [ "$result" = "error" ]; then
 +    pass ">&2 redirects stdout to stderr"
 +else
 +    fail ">&2 redirects stdout to stderr" "error" "$result"
 +fi
++
 +# 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)
 +if [ "$result" = "error" ]; then
 +    pass "1>&2 with stderr suppressed (matches bash)"
 +else
 +    fail "1>&2 with stderr suppressed (matches bash)" "error" "$result"
 +fi
++
 +# =====================================
 +section "434. COMBINED REDIRECTIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +expected=$(printf "out\nerr")
 +if [ "$result" = "$expected" ]; then
 +    pass "Both streams to same file"
 +else
 +    fail "Both streams to same file" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "435. NOCLOBBER WITH >|"
 +# =====================================
++
 +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)
 +if [ "$result" = "new" ]; then
 +    pass ">| overrides noclobber"
 +else
 +    fail ">| overrides noclobber" "new" "$result"
 +fi
++
 +# =====================================
 +section "436. SIMPLE PIPELINE"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +expected=$(printf "a\nb\nc")
 +if [ "$result" = "$expected" ]; then
 +    pass "Pipeline with sort"
 +else
 +    fail "Pipeline with sort" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "437. MULTI-STAGE PIPELINE"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +expected=$(printf "a\nb\nc")
 +if [ "$result" = "$expected" ]; then
 +    pass "sort | uniq pipeline"
 +else
 +    fail "sort | uniq pipeline" "$expected" "$result"
 +fi
++
 +result=$("$FORTSH_BIN" -c 'echo "hello world" | tr " " "\n" | wc -l' 2>&1)
 +if echo "$result" | grep -q "2"; then
 +    pass "tr | wc pipeline"
 +else
 +    fail "tr | wc pipeline" "2" "$result"
 +fi
++
 +# =====================================
 +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)
 +if [ "$result" = "hello" ]; then
 +    pass "Pipeline with output redirect"
 +else
 +    fail "Pipeline with output redirect" "hello" "$result"
 +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)
 +if [ "$result" = "FROM FILE" ]; then
 +    pass "Input redirect into pipeline"
 +else
 +    fail "Input redirect into pipeline" "FROM FILE" "$result"
 +fi
++
 +# =====================================
 +section "439. PIPELINE SUBSHELL"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +expected=$(printf "test\ndone")
 +if [ "$result" = "$expected" ]; then
 +    pass "Pipeline to subshell"
 +else
 +    fail "Pipeline to subshell" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "440. COMMAND SUBSTITUTION IN PIPELINE"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if echo "$result" | grep -q "3"; then
 +    pass "Variable from pipeline in command sub"
 +else
 +    fail "Variable from pipeline in command sub" "3" "$result"
 +fi
++
 +# =====================================
 +section "441. REDIRECTION ORDER"
 +# =====================================
++
 +# 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)
 +if echo "$result" | grep -q "2"; then
 +    pass "> file 2>&1 captures both"
 +else
 +    fail "> file 2>&1 captures both" "2 lines" "$result"
 +fi
++
 +# =====================================
 +section "442. /dev/null REDIRECTION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +# Should show non-zero exit but no error output
 +if echo "$result" | grep -qE "^[12]$"; then
 +    pass "2>/dev/null with failing command"
 +else
 +    fail "2>/dev/null with failing command" "exit code only" "$result"
 +fi
++
 +# =====================================
 +section "443. PROCESS SUBSTITUTION STYLE"
 +# =====================================
++
 +# 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)
 +# This may not be supported - just document if it works
 +if [ "$result" = "0" ]; then
 +    pass "Process substitution <() works"
 +else
 +    skip "Process substitution <() works" "bash extension"
 +fi
++
 +# =====================================
 +section "444. CLOSING FILE DESCRIPTORS"
 +# =====================================
++
 +result=$("$FORTSH_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)"
 +else
 +    pass ">&- closes stdout (caused error)"
 +fi
++
 +# =====================================
 +section "445. DUPLICATING INPUT"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo test | { cat; } 0<&0' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "0<&0 duplicates stdin"
 +else
 +    fail "0<&0 duplicates stdin" "test" "$result"
 +fi
++
 +# =====================================
 +section "446. PIPELINE EXIT STATUS"
 +# =====================================
++
 +# Last command determines exit status
 +result=$("$FORTSH_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)
 +if [ "$result" = "1" ]; then
 +    pass "Pipeline exit is last command (true|false=1)"
 +else
 +    fail "Pipeline exit is last command (true|false=1)" "1" "$result"
 +fi
++
 +# Multi-stage pipeline
 +result=$("$FORTSH_BIN" -c 'echo a | cat | cat | cat; echo $?' 2>&1)
 +if echo "$result" | grep -q "0"; then
 +    pass "Multi-stage pipeline success"
 +else
 +    fail "Multi-stage pipeline success" "0" "$result"
 +fi
++
 +# Pipeline with negation
 +result=$("$FORTSH_BIN" -c '! false | true; echo $?' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "! negates pipeline exit"
 +else
 +    fail "! negates pipeline exit" "1" "$result"
 +fi
++
 +# =====================================
 +section "447. EXEC REDIRECTIONS"
 +# =====================================
++
 +# exec without command modifies shell FDs
 +result=$("$FORTSH_BIN" -c '
 +exec 3>"'"$TEST_DIR"'/exec_fd3.txt"
 +echo "fd3 data" >&3
 +exec 3>&-
 +cat "'"$TEST_DIR"'/exec_fd3.txt"
 +' 2>&1)
 +if [ "$result" = "fd3 data" ]; then
 +    pass "exec opens FD 3 for writing"
 +else
 +    fail "exec opens FD 3 for writing" "fd3 data" "$result"
 +fi
++
 +# exec read/write mode
 +result=$("$FORTSH_BIN" -c '
 +echo "initial" > "'"$TEST_DIR"'/rw_test.txt"
 +exec 4<>"'"$TEST_DIR"'/rw_test.txt"
 +read line <&4
 +echo "read: $line"
 +exec 4>&-
 +' 2>&1)
 +if [ "$result" = "read: initial" ]; then
 +    pass "exec <> opens read-write"
 +else
 +    fail "exec <> opens read-write" "read: initial" "$result"
 +fi
++
 +# =====================================
 +section "448. COMPOUND REDIRECTIONS"
 +# =====================================
++
 +# Redirect entire loop
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2 3; do
 +    echo $i
 +done > "'"$TEST_DIR"'/loop_out.txt"
 +cat "'"$TEST_DIR"'/loop_out.txt"
 +' 2>&1)
 +expected=$(printf "1\n2\n3")
 +if [ "$result" = "$expected" ]; then
 +    pass "Redirect entire for loop"
 +else
 +    fail "Redirect entire for loop" "$expected" "$result"
 +fi
++
 +# Redirect if statement
 +result=$("$FORTSH_BIN" -c '
 +if true; then
 +    echo inside
 +fi > "'"$TEST_DIR"'/if_out.txt"
 +cat "'"$TEST_DIR"'/if_out.txt"
 +' 2>&1)
 +if [ "$result" = "inside" ]; then
 +    pass "Redirect entire if statement"
 +else
 +    fail "Redirect entire if statement" "inside" "$result"
 +fi
++
 +# Redirect case statement
 +result=$("$FORTSH_BIN" -c '
 +case "x" in
 +    x) echo matched;;
 +esac > "'"$TEST_DIR"'/case_out.txt"
 +cat "'"$TEST_DIR"'/case_out.txt"
 +' 2>&1)
 +if [ "$result" = "matched" ]; then
 +    pass "Redirect entire case statement"
 +else
 +    fail "Redirect entire case statement" "matched" "$result"
 +fi
++
 +# =====================================
 +section "449. INPUT REDIRECTION VARIATIONS"
 +# =====================================
++
 +# 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)
 +expected=$(printf "file1\nfile2")
 +if [ "$result" = "$expected" ]; then
 +    pass "cat multiple files"
 +else
 +    fail "cat multiple files" "$expected" "$result"
 +fi
++
 +# Input from file
 +echo "from file" > "$TEST_DIR/input.txt"
 +result=$("$FORTSH_BIN" -c 'cat < "'"$TEST_DIR"'/input.txt"' 2>&1)
 +if [ "$result" = "from file" ]; then
 +    pass "< redirects stdin from file"
 +else
 +    fail "< redirects stdin from file" "from file" "$result"
 +fi
++
 +# =====================================
 +section "450. OUTPUT APPEND BEHAVIOR"
 +# =====================================
++
 +# >> 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)
 +if [ "$result" = "first" ]; then
 +    pass ">> creates file if not exists"
 +else
 +    fail ">> creates file if not exists" "first" "$result"
 +fi
++
 +# >> 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)
 +expected=$(printf "line1\nline2")
 +if [ "$result" = "$expected" ]; then
 +    pass ">> appends to existing file"
 +else
 +    fail ">> appends to existing file" "$expected" "$result"
 +fi
++
 +# Multiple appends
 +rm -f "$TEST_DIR/multi_append.txt"
 +result=$("$FORTSH_BIN" -c '
 +echo a >> "'"$TEST_DIR"'/multi_append.txt"
 +echo b >> "'"$TEST_DIR"'/multi_append.txt"
 +echo c >> "'"$TEST_DIR"'/multi_append.txt"
 +cat "'"$TEST_DIR"'/multi_append.txt"
 +' 2>&1)
 +expected=$(printf "a\nb\nc")
 +if [ "$result" = "$expected" ]; then
 +    pass "Multiple sequential appends"
 +else
 +    fail "Multiple sequential appends" "$expected" "$result"
 +fi
++
 +# =====================================
 +section "451. REDIRECT WITH ASSIGNMENTS"
 +# =====================================
++
 +# Assignment with redirect
 +result=$("$FORTSH_BIN" -c 'x=$(cat < /dev/null); echo "empty:[$x]"' 2>&1)
 +if [ "$result" = "empty:[]" ]; then
 +    pass "Assignment from empty file"
 +else
 +    fail "Assignment from empty file" "empty:[]" "$result"
 +fi
++
 +# Assignment captures command output despite redirects
 +result=$("$FORTSH_BIN" -c 'x=$(echo hello 2>/dev/null); echo $x' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "Assignment captures stdout"
 +else
 +    fail "Assignment captures stdout" "hello" "$result"
 +fi
++
 +# =====================================
 +section "452. HEREDOC VARIATIONS"
 +# =====================================
++
 +# Basic heredoc
 +result=$("$FORTSH_BIN" -c 'cat <<END
 +hello
 +END' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "Basic heredoc"
 +else
 +    fail "Basic heredoc" "hello" "$result"
 +fi
++
 +# Heredoc with variable expansion
 +result=$("$FORTSH_BIN" -c 'X=world; cat <<END
 +hello $X
 +END' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "Heredoc with variable expansion"
 +else
 +    fail "Heredoc with variable expansion" "hello world" "$result"
 +fi
++
 +# Quoted heredoc prevents expansion
 +result=$("$FORTSH_BIN" -c 'cat <<'\''END'\''
 +$VAR
 +END' 2>&1)
 +if [ "$result" = '$VAR' ]; then
 +    pass "Quoted heredoc prevents expansion"
 +else
 +    fail "Quoted heredoc prevents expansion" "\$VAR" "$result"
 +fi
++
 +# =====================================
 +section "453. PIPELINE VARIATIONS"
 +# =====================================
++
 +# Long pipeline
 +result=$("$FORTSH_BIN" -c 'echo test | cat | cat | cat | cat' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "Long pipeline with multiple cats"
 +else
 +    fail "Long pipeline with multiple cats" "test" "$result"
 +fi
++
 +# Pipeline with head
 +result=$("$FORTSH_BIN" -c 'printf "a\nb\nc\n" | head -1' 2>&1)
 +if [ "$result" = "a" ]; then
 +    pass "Pipeline with head"
 +else
 +    fail "Pipeline with head" "a" "$result"
 +fi
++
 +# Pipeline with tail
 +result=$("$FORTSH_BIN" -c 'printf "a\nb\nc\n" | tail -1' 2>&1)
 +if [ "$result" = "c" ]; then
 +    pass "Pipeline with tail"
 +else
 +    fail "Pipeline with tail" "c" "$result"
 +fi
++
 +# Pipeline with sort
 +result=$("$FORTSH_BIN" -c 'printf "c\na\nb\n" | sort | head -1' 2>&1)
 +if [ "$result" = "a" ]; then
 +    pass "Pipeline with sort"
 +else
 +    fail "Pipeline with sort" "a" "$result"
 +fi
++
 +# =====================================
 +section "454. FILE DESCRIPTOR OPERATIONS"
 +# =====================================
++
 +# Dup stdout to stderr
 +result=$("$FORTSH_BIN" -c 'echo test >&2' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "Redirect stdout to stderr"
 +else
 +    fail "Redirect stdout to stderr" "test" "$result"
 +fi
++
 +# 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)
 +if echo "$result" | grep -q "Bad file descriptor"; then
 +    pass "Close stdout after redirect (matches bash - write error)"
 +else
 +    fail "Close stdout after redirect (matches bash - write error)" "Bad file descriptor error" "$result"
 +fi
++
 +# =====================================
 +section "455. INPUT REDIRECTION VARIATIONS"
 +# =====================================
++
 +# Input from file
 +echo "content" > "$TEST_DIR/input_test.txt"
 +result=$("$FORTSH_BIN" -c 'cat < "'"$TEST_DIR"'/input_test.txt"' 2>&1)
 +if [ "$result" = "content" ]; then
 +    pass "Input redirection from file"
 +else
 +    fail "Input redirection from file" "content" "$result"
 +fi
++
 +# Input from /dev/null
 +result=$("$FORTSH_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
 +    fail "Input from /dev/null is empty" "0" "$result"
 +fi
++
 +# =====================================
 +section "456. OUTPUT TO /dev/null"
 +# =====================================
++
 +# Stdout to /dev/null
 +result=$("$FORTSH_BIN" -c 'echo hidden > /dev/null; echo visible' 2>&1)
 +if [ "$result" = "visible" ]; then
 +    pass "Stdout to /dev/null suppresses output"
 +else
 +    fail "Stdout to /dev/null suppresses output" "visible" "$result"
 +fi
++
 +# Stderr to /dev/null
 +result=$("$FORTSH_BIN" -c 'ls /nonexistent 2>/dev/null; echo done' 2>&1)
 +if [ "$result" = "done" ]; then
 +    pass "Stderr to /dev/null suppresses errors"
 +else
 +    fail "Stderr to /dev/null suppresses errors" "done" "$result"
 +fi
++
 +# Both to /dev/null
 +result=$("$FORTSH_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
 +    fail "Both stdout and stderr to /dev/null"
 +fi
++
 +# =====================================
 +section "457. NOCLOBBER BEHAVIOR"
 +# =====================================
++
 +# 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)
 +if [ "$result" = "new" ]; then
 +    pass "Normal > overwrites file"
 +else
 +    fail "Normal > overwrites file" "new" "$result"
 +fi
++
 +# =====================================
 +section "458. COMPOUND REDIRECTIONS"
 +# =====================================
++
 +# 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)
 +if [ "$result" = "yes" ]; then
 +    pass "Redirect if statement output"
 +else
 +    fail "Redirect if statement output" "yes" "$result"
 +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)
 +if [ "$result" -eq 3 ] 2>/dev/null; then
 +    pass "Redirect while loop output"
 +else
 +    fail "Redirect while loop output" "3" "$result"
 +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)
 +if [ "$result" -eq 3 ] 2>/dev/null; then
 +    pass "Redirect for loop output"
 +else
 +    fail "Redirect for loop output" "3" "$result"
 +fi
++
 +# =====================================
 +section "459. PIPELINE EXIT STATUS"
 +# =====================================
++
 +# Last command determines exit
 +result=$("$FORTSH_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)
 +if [ "$result" = "0" ]; then
 +    pass "Pipeline exit from last command (true)"
 +else
 +    fail "Pipeline exit from last command (true)" "0" "$result"
 +fi
++
 +# =====================================
 +section "460. MULTIPLE REDIRECTIONS"
 +# =====================================
++
 +# 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)
 +if [ "$result" = "input" ]; then
 +    pass "Both input and output redirect"
 +else
 +    fail "Both input and output redirect" "input" "$result"
 +fi
++
 +# Order of redirections
 +result=$("$FORTSH_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
 +    fail "Redirect order: > then 2>&1" "test" "$result"
 +fi
++
 +# =====================================
 +section "461. PIPELINE WITH SUBSHELL"
 +# =====================================
++
 +# Subshell in pipeline
 +result=$("$FORTSH_BIN" -c '(echo a; echo b) | wc -l' 2>&1)
 +if [ "$result" -eq 2 ] 2>/dev/null; then
 +    pass "Subshell in pipeline"
 +else
 +    fail "Subshell in pipeline" "2" "$result"
 +fi
++
 +# Brace group in pipeline
 +result=$("$FORTSH_BIN" -c '{ echo x; echo y; } | wc -l' 2>&1)
 +if [ "$result" -eq 2 ] 2>/dev/null; then
 +    pass "Brace group in pipeline"
 +else
 +    fail "Brace group in pipeline" "2" "$result"
 +fi
++
 +# =====================================
 +section "462. REDIRECT AND PIPELINE COMBO"
 +# =====================================
++
 +# Pipeline with final redirect
 +result=$("$FORTSH_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
 +    fail "Pipeline with final redirect" "test" "$result"
 +fi
++
 +# Redirect within pipeline
 +result=$("$FORTSH_BIN" -c 'echo test 2>/dev/null | cat' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "Redirect within pipeline stage"
 +else
 +    fail "Redirect within pipeline stage" "test" "$result"
 +fi
++
 +# =====================================
 +section "463. HERE STRING ALTERNATIVES"
 +# =====================================
++
 +# Echo pipe as here-string alternative
 +result=$("$FORTSH_BIN" -c 'echo "test" | cat' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "Echo pipe as here-string alternative"
 +else
 +    fail "Echo pipe as here-string alternative" "test" "$result"
 +fi
++
 +# Printf pipe
 +result=$("$FORTSH_BIN" -c 'printf "%s" "test" | cat' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "Printf pipe"
 +else
 +    fail "Printf pipe" "test" "$result"
 +fi
++
 +# =====================================
 +section "464. REDIRECTION EDGE CASES"
 +# =====================================
++
 +# 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)
 +if [ "$result" = "new" ]; then
 +    pass "Multiple redirects to same file"
 +else
 +    fail "Multiple redirects to same file" "new" "$result"
 +fi
++
 +# 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)
 +if [ "$result" = "exists" ]; then
 +    pass "Empty redirect creates file"
 +else
 +    fail "Empty redirect creates file" "exists" "$result"
 +fi
++
 +# =====================================
 +section "465. TPYE WITH REDIRECTION"
 +# =====================================
++
 +# Pipeline preserves data integrity
 +result=$("$FORTSH_BIN" -c 'echo "hello world" | cat | cat | cat' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "Pipeline preserves data integrity"
 +else
 +    fail "Pipeline preserves data integrity" "hello world" "$result"
 +fi
++
 +# Multiple pipes with tr
 +result=$("$FORTSH_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
 +    fail "Multiple pipes with tr" "XYZ" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Redirection and Pipeline Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_special.shadded

1396 lines changed — click to load

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Special Variables and Features Test Suite
 +# =====================================
 +# Tests for special variables, file descriptors, and advanced features
 +# per IEEE Std 1003.1-2017
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-special]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
++
 +# 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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    printf "${RED}✗ FAIL${NC} ${TEST_ID}: %s\n" "$1"
 +    FAILED_TESTS_LIST="${FAILED_TESTS_LIST}  ${TEST_ID}: $1\n"
 +    if [ -n "$2" ]; then
 +        printf "  expected: %s\n" "$2"
 +    fi
 +    if [ -n "$3" ]; then
 +        printf "  got:      %s\n" "$3"
 +    fi
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# =====================================
 +section "358. SPECIAL VARIABLE LINENO"
 +# =====================================
++
 +# LINENO in simple script
 +result=$("$FORTSH_BIN" -c 'echo $LINENO' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "LINENO is 1 on first line"
 +else
 +    fail "LINENO is 1 on first line" "1" "$result"
 +fi
++
 +# LINENO increments
 +result=$("$FORTSH_BIN" -c '
 +echo $LINENO
 +echo $LINENO
 +echo $LINENO
 +' 2>&1)
 +if echo "$result" | grep -q "2" && echo "$result" | grep -q "3" && echo "$result" | grep -q "4"; then
 +    pass "LINENO increments across lines"
 +else
 +    fail "LINENO increments across lines" "2 3 4" "$result"
 +fi
++
 +# LINENO in function
 +result=$("$FORTSH_BIN" -c '
 +func() {
 +    echo $LINENO
 +}
 +func
 +' 2>&1)
 +if [ -n "$result" ] && [ "$result" -gt 0 ] 2>/dev/null; then
 +    pass "LINENO works in function"
 +else
 +    fail "LINENO works in function" "positive number" "$result"
 +fi
++
 +# =====================================
 +section "359. SPECIAL VARIABLE PPID"
 +# =====================================
++
 +# PPID is set
 +result=$("$FORTSH_BIN" -c 'echo $PPID' 2>&1)
 +if [ -n "$result" ] && [ "$result" -gt 0 ] 2>/dev/null; then
 +    pass "PPID is set to positive number"
 +else
 +    fail "PPID is set to positive number" "positive pid" "$result"
 +fi
++
 +# PPID matches parent
 +parent_pid=$$
 +result=$("$FORTSH_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"
 +else
 +    fail "PPID is reasonable value" ">1" "$result"
 +fi
++
 +# PPID is readonly conceptually (cannot be assigned)
 +result=$("$FORTSH_BIN" -c 'PPID=999; echo $PPID' 2>&1)
 +if [ "$result" != "999" ]; then
 +    pass "PPID cannot be overwritten"
 +else
 +    fail "PPID cannot be overwritten" "not 999" "$result"
 +fi
++
 +# =====================================
 +section "360. FILE DESCRIPTOR 3-9"
 +# =====================================
++
 +# FD 3 redirect out
 +result=$("$FORTSH_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 '
 +exec 3>/tmp/fd3exec_$$
 +echo "fd3 output" >&3
 +exec 3>&-
 +cat /tmp/fd3exec_$$
 +rm -f /tmp/fd3exec_$$
 +' 2>&1)
 +if echo "$result" | grep -q "fd3 output"; then
 +    pass "exec with FD 3 works"
 +else
 +    fail "exec with FD 3 works" "fd3 output" "$result"
 +fi
++
 +# FD 4 usage
 +result=$("$FORTSH_BIN" -c '
 +exec 4>/tmp/fd4test_$$
 +echo "fd4 data" >&4
 +exec 4>&-
 +cat /tmp/fd4test_$$
 +rm -f /tmp/fd4test_$$
 +' 2>&1)
 +if echo "$result" | grep -q "fd4 data"; then
 +    pass "FD 4 works correctly"
 +else
 +    fail "FD 4 works correctly" "fd4 data" "$result"
 +fi
++
 +# Multiple FDs
 +result=$("$FORTSH_BIN" -c '
 +exec 3>/tmp/fd3m_$$ 4>/tmp/fd4m_$$
 +echo "three" >&3
 +echo "four" >&4
 +exec 3>&- 4>&-
 +cat /tmp/fd3m_$$ /tmp/fd4m_$$
 +rm -f /tmp/fd3m_$$ /tmp/fd4m_$$
 +' 2>&1)
 +if echo "$result" | grep -q "three" && echo "$result" | grep -q "four"; then
 +    pass "Multiple FDs (3 and 4) work together"
 +else
 +    fail "Multiple FDs (3 and 4) work together" "three four" "$result"
 +fi
++
 +# =====================================
 +section "361. COLON BUILTIN"
 +# =====================================
++
 +# Colon is no-op, returns 0
 +result=$("$FORTSH_BIN" -c ':; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass ": returns exit status 0"
 +else
 +    fail ": returns exit status 0" "0" "$result"
 +fi
++
 +# Colon with arguments (ignored)
 +result=$("$FORTSH_BIN" -c ': arg1 arg2 arg3; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass ": ignores arguments"
 +else
 +    fail ": ignores arguments" "0" "$result"
 +fi
++
 +# Colon with variable expansion (expansion happens but result ignored)
 +result=$("$FORTSH_BIN" -c 'x=1; : $((x=x+1)); echo $x' 2>&1)
 +if [ "$result" = "2" ]; then
 +    pass ": performs expansions but ignores result"
 +else
 +    fail ": performs expansions but ignores result" "2" "$result"
 +fi
++
 +# Colon in conditional
 +result=$("$FORTSH_BIN" -c 'if :; then echo yes; fi' 2>&1)
 +if [ "$result" = "yes" ]; then
 +    pass ": works in if condition"
 +else
 +    fail ": works in if condition" "yes" "$result"
 +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)
 +if [ "$result" = "3" ]; then
 +    pass ": works in while loop"
 +else
 +    fail ": works in while loop" "3" "$result"
 +fi
++
 +# =====================================
 +section "362. COMPOUND COMMAND NESTING"
 +# =====================================
++
 +# Nested subshells
 +result=$("$FORTSH_BIN" -c 'echo $(echo $(echo deep))' 2>&1)
 +if [ "$result" = "deep" ]; then
 +    pass "Triple nested command substitution"
 +else
 +    fail "Triple nested command substitution" "deep" "$result"
 +fi
++
 +# Nested braces
 +result=$("$FORTSH_BIN" -c '{ { { echo nested; }; }; }' 2>&1)
 +if [ "$result" = "nested" ]; then
 +    pass "Triple nested brace groups"
 +else
 +    fail "Triple nested brace groups" "nested" "$result"
 +fi
++
 +# Mixed nesting
 +result=$("$FORTSH_BIN" -c '{ x=$(echo inner); echo $x; }' 2>&1)
 +if [ "$result" = "inner" ]; then
 +    pass "Command substitution in brace group"
 +else
 +    fail "Command substitution in brace group" "inner" "$result"
 +fi
++
 +# Nested loops
 +result=$("$FORTSH_BIN" -c '
 +for i in 1 2; do
 +    for j in a b; do
 +        echo "$i$j"
 +    done
 +done
 +' 2>&1)
 +if echo "$result" | grep -q "1a" && echo "$result" | grep -q "2b"; then
 +    pass "Nested for loops"
 +else
 +    fail "Nested for loops" "1a 1b 2a 2b" "$result"
 +fi
++
 +# =====================================
 +section "363. COMPLEX PARAMETER EXPANSION"
 +# =====================================
++
 +# Nested parameter expansion
 +result=$("$FORTSH_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)
 +if [ "$result" = "default" ]; then
 +    pass "Nested default expansion (fallback to nested)"
 +else
 +    fail "Nested default expansion (fallback to nested)" "default" "$result"
 +fi
++
 +# Length of expansion result
 +result=$("$FORTSH_BIN" -c 'x=hello; echo ${#x}' 2>&1)
 +if [ "$result" = "5" ]; then
 +    pass "Length of variable"
 +else
 +    fail "Length of variable" "5" "$result"
 +fi
++
 +# Pattern removal chained
 +result=$("$FORTSH_BIN" -c 'x="/path/to/file.txt"; y=${x##*/}; z=${y%.*}; echo $z' 2>&1)
 +if [ "$result" = "file" ]; then
 +    pass "Chained pattern removal"
 +else
 +    fail "Chained pattern removal" "file" "$result"
 +fi
++
 +# =====================================
 +section "364. SPECIAL EXPANSION CONTEXTS"
 +# =====================================
++
 +# Expansion in here-document
 +result=$("$FORTSH_BIN" -c 'x=VALUE; cat <<EOF
 +$x
 +EOF' 2>&1)
 +if [ "$result" = "VALUE" ]; then
 +    pass "Variable expansion in heredoc"
 +else
 +    fail "Variable expansion in heredoc" "VALUE" "$result"
 +fi
++
 +# No expansion in quoted heredoc
 +result=$("$FORTSH_BIN" -c "x=VALUE; cat <<'EOF'
 +\$x
 +EOF" 2>&1)
 +if [ "$result" = '$x' ]; then
 +    pass "No expansion in quoted heredoc delimiter"
 +else
 +    fail "No expansion in quoted heredoc delimiter" '$x' "$result"
 +fi
++
 +# Expansion in case pattern
 +result=$("$FORTSH_BIN" -c 'pat="hel*"; case "hello" in $pat) echo match;; esac' 2>&1)
 +if [ "$result" = "match" ]; then
 +    pass "Variable expansion in case pattern"
 +else
 +    fail "Variable expansion in case pattern" "match" "$result"
 +fi
++
 +# =====================================
 +section "365. ARITHMETIC EDGE CASES"
 +# =====================================
++
 +# Unary minus
 +result=$("$FORTSH_BIN" -c 'echo $((-5))' 2>&1)
 +if [ "$result" = "-5" ]; then
 +    pass "Unary minus in arithmetic"
 +else
 +    fail "Unary minus in arithmetic" "-5" "$result"
 +fi
++
 +# Unary plus
 +result=$("$FORTSH_BIN" -c 'echo $((+5))' 2>&1)
 +if [ "$result" = "5" ]; then
 +    pass "Unary plus in arithmetic"
 +else
 +    fail "Unary plus in arithmetic" "5" "$result"
 +fi
++
 +# Logical NOT
 +result=$("$FORTSH_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)
 +if [ "$result" = "0" ]; then
 +    pass "Logical NOT of 1"
 +else
 +    fail "Logical NOT of 1" "0" "$result"
 +fi
++
 +# Bitwise NOT
 +result=$("$FORTSH_BIN" -c 'echo $((~0))' 2>&1)
 +if [ "$result" = "-1" ]; then
 +    pass "Bitwise NOT of 0"
 +else
 +    fail "Bitwise NOT of 0" "-1" "$result"
 +fi
++
 +# Complex expression
 +result=$("$FORTSH_BIN" -c 'echo $(( (2 + 3) * 4 - 1 ))' 2>&1)
 +if [ "$result" = "19" ]; then
 +    pass "Complex arithmetic with parens"
 +else
 +    fail "Complex arithmetic with parens" "19" "$result"
 +fi
++
 +# =====================================
 +section "366. SIGNAL NAME HANDLING"
 +# =====================================
++
 +# trap with signal name
 +result=$("$FORTSH_BIN" -c 'trap "echo caught" INT; trap' 2>&1)
 +if echo "$result" | grep -qE "INT|SIGINT"; then
 +    pass "trap accepts signal name"
 +else
 +    fail "trap accepts signal name" "INT or SIGINT" "$result"
 +fi
++
 +# trap with signal number
 +result=$("$FORTSH_BIN" -c 'trap "echo caught" 2; trap' 2>&1)
 +if echo "$result" | grep -qE "INT|SIGINT|2"; then
 +    pass "trap accepts signal number"
 +else
 +    fail "trap accepts signal number" "signal 2 info" "$result"
 +fi
++
 +# Multiple signals
 +result=$("$FORTSH_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
 +    fail "trap with multiple signals" "EXIT and INT" "$result"
 +fi
++
 +# =====================================
 +section "367. QUOTING EDGE CASES"
 +# =====================================
++
 +# Single quotes preserve everything
 +result=$("$FORTSH_BIN" -c "echo 'hello\nworld'" 2>&1)
 +if [ "$result" = 'hello\nworld' ]; then
 +    pass "Single quotes preserve backslash-n literally"
 +else
 +    fail "Single quotes preserve backslash-n literally" 'hello\nworld' "$result"
 +fi
++
 +# Empty string quoting
 +result=$("$FORTSH_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
 +    pass "Empty quoted string produces empty output"
 +else
 +    fail "Empty quoted string produces empty output" "1" "$result"
 +fi
++
 +# Quote within quote
 +result=$("$FORTSH_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)
 +if [ "$result" = 'say "hello"' ]; then
 +    pass "Escaped quotes in double quotes"
 +else
 +    fail "Escaped quotes in double quotes" 'say "hello"' "$result"
 +fi
++
 +# =====================================
 +section "368. WORD SPLITTING EDGE CASES"
 +# =====================================
++
 +# Empty IFS prevents splitting
 +result=$("$FORTSH_BIN" -c 'IFS=""; x="a b c"; set -- $x; echo $#' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "Empty IFS prevents word splitting"
 +else
 +    fail "Empty IFS prevents word splitting" "1" "$result"
 +fi
++
 +# IFS with multiple characters
 +result=$("$FORTSH_BIN" -c 'IFS=":,"; x="a:b,c"; set -- $x; echo $#' 2>&1)
 +if [ "$result" = "3" ]; then
 +    pass "IFS with multiple delimiters"
 +else
 +    fail "IFS with multiple delimiters" "3" "$result"
 +fi
++
 +# Default IFS restoration
 +result=$("$FORTSH_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
 +    fail "unset IFS restores default splitting" "2" "$result"
 +fi
++
 +# =====================================
 +section "369. $$ IN SUBSHELLS"
 +# =====================================
++
 +# $$ 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)
 +parent_pid=$(echo "$result" | sed -n '1p')
 +subshell_pid=$(echo "$result" | sed -n '2p')
 +if [ "$parent_pid" = "$subshell_pid" ]; then
 +    pass "\$\$ in subshell returns parent shell PID"
 +else
 +    fail "\$\$ in subshell returns parent shell PID" "$parent_pid" "$subshell_pid"
 +fi
++
 +# $$ in command substitution
 +result=$("$FORTSH_BIN" -c 'echo $$ $(echo $$)' 2>&1)
 +# Both should be the same PID
 +pid1=$(echo "$result" | awk '{print $1}')
 +pid2=$(echo "$result" | awk '{print $2}')
 +if [ "$pid1" = "$pid2" ]; then
 +    pass "\$\$ in command substitution matches parent"
 +else
 +    fail "\$\$ in command substitution matches parent" "same" "$result"
 +fi
++
 +# $$ is numeric
 +result=$("$FORTSH_BIN" -c 'echo $$' 2>&1)
 +if [ "$result" -gt 0 ] 2>/dev/null; then
 +    pass "\$\$ is positive integer"
 +else
 +    fail "\$\$ is positive integer" ">0" "$result"
 +fi
++
 +# =====================================
 +section "370. \$@ VS \$* DIFFERENCES"
 +# =====================================
++
 +# $@ preserves separate arguments
 +result=$("$FORTSH_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'
 +else
 +    fail '"\$@" preserves argument boundaries' "$expected" "$result"
 +fi
++
 +# $* joins with IFS
 +result=$("$FORTSH_BIN" -c 'IFS=":"; set -- a b c; echo "$*"' 2>&1)
 +if [ "$result" = "a:b:c" ]; then
 +    pass '"\$*" joins with first char of IFS'
 +else
 +    fail '"\$*" joins with first char of IFS' "a:b:c" "$result"
 +fi
++
 +# $@ unquoted splits
 +result=$("$FORTSH_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
 +    pass 'Unquoted $@ splits on whitespace'
 +else
 +    fail 'Unquoted $@ splits on whitespace' "$expected" "$result"
 +fi
++
 +# Empty $@ produces nothing
 +result=$("$FORTSH_BIN" -c 'set --; for x in "$@"; do echo X; done; echo done' 2>&1)
 +if [ "$result" = "done" ]; then
 +    pass 'Empty "$@" produces no iterations'
 +else
 +    fail 'Empty "$@" produces no iterations' "done" "$result"
 +fi
++
 +# $# count
 +result=$("$FORTSH_BIN" -c 'set -- a b c d e; echo $#' 2>&1)
 +if [ "$result" = "5" ]; then
 +    pass '$# counts positional parameters'
 +else
 +    fail '$# counts positional parameters' "5" "$result"
 +fi
++
 +# =====================================
 +section "371. PWD AND OLDPWD"
 +# =====================================
++
 +# PWD is set
 +result=$("$FORTSH_BIN" -c 'echo $PWD' 2>&1)
 +if [ -n "$result" ] && [ -d "$result" ]; then
 +    pass "PWD is set to valid directory"
 +else
 +    fail "PWD is set to valid directory" "directory path" "$result"
 +fi
++
 +# cd updates PWD
 +result=$("$FORTSH_BIN" -c 'cd /tmp && echo $PWD' 2>&1)
 +if echo "$result" | grep -q "tmp"; then
 +    pass "cd updates PWD"
 +else
 +    fail "cd updates PWD" "/tmp" "$result"
 +fi
++
 +# cd updates OLDPWD
 +result=$("$FORTSH_BIN" -c 'cd /; cd /tmp; echo $OLDPWD' 2>&1)
 +if [ "$result" = "/" ]; then
 +    pass "cd updates OLDPWD"
 +else
 +    fail "cd updates OLDPWD" "/" "$result"
 +fi
++
 +# cd - uses OLDPWD
 +result=$("$FORTSH_BIN" -c 'cd /; cd /tmp; cd -' 2>&1)
 +if echo "$result" | grep -q "/"; then
 +    pass "cd - prints previous directory"
 +else
 +    fail "cd - prints previous directory" "/" "$result"
 +fi
++
 +# =====================================
 +section "372. \$? EXIT STATUS"
 +# =====================================
++
 +# $? after successful command
 +result=$("$FORTSH_BIN" -c 'true; echo $?' 2>&1)
 +if [ "$result" = "0" ]; then
 +    pass '$? is 0 after true'
 +else
 +    fail '$? is 0 after true' "0" "$result"
 +fi
++
 +# $? after failed command
 +result=$("$FORTSH_BIN" -c 'false; echo $?' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass '$? is 1 after false'
 +else
 +    fail '$? is 1 after false' "1" "$result"
 +fi
++
 +# $? after exit N
 +result=$("$FORTSH_BIN" -c '(exit 42); echo $?' 2>&1)
 +if [ "$result" = "42" ]; then
 +    pass '$? captures exit code from subshell'
 +else
 +    fail '$? captures exit code from subshell' "42" "$result"
 +fi
++
 +# $? after signal (128+signal)
 +result=$("$FORTSH_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
 +    fail '$? is 128+ after signal death' ">=128" "$result"
 +fi
++
 +# $? after command not found
 +result=$("$FORTSH_BIN" -c 'nonexistent_cmd_xyz_12345 2>/dev/null; echo $?' 2>&1)
 +if [ "$result" = "127" ]; then
 +    pass '$? is 127 for command not found'
 +else
 +    fail '$? is 127 for command not found' "127" "$result"
 +fi
++
 +# =====================================
 +section "373. \$0 SCRIPT NAME"
 +# =====================================
++
 +# $0 in -c command
 +result=$("$FORTSH_BIN" -c 'echo $0' 2>&1)
 +if [ -n "$result" ]; then
 +    pass '$0 is set in -c command'
 +else
 +    fail '$0 is set in -c command' "non-empty" "$result"
 +fi
++
 +# $0 can be set with -c
 +result=$("$FORTSH_BIN" -c 'echo $0' myname 2>&1)
 +if [ "$result" = "myname" ]; then
 +    pass '$0 can be set via argument after -c'
 +else
 +    fail '$0 can be set via argument after -c' "myname" "$result"
 +fi
++
 +# =====================================
 +section "374. SHIFT EDGE CASES"
 +# =====================================
++
 +# shift removes first positional param
 +result=$("$FORTSH_BIN" -c 'set -- a b c; shift; echo $1' 2>&1)
 +if [ "$result" = "b" ]; then
 +    pass 'shift removes first parameter'
 +else
 +    fail 'shift removes first parameter' "b" "$result"
 +fi
++
 +# shift N removes N params
 +result=$("$FORTSH_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
 +    fail 'shift N removes N parameters' "c" "$result"
 +fi
++
 +# shift updates $#
 +result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 3; echo $#' 2>&1)
 +if [ "$result" = "2" ]; then
 +    pass 'shift updates $#'
 +else
 +    fail 'shift updates $#' "2" "$result"
 +fi
++
 +# shift more than $# fails
 +result=$("$FORTSH_BIN" -c 'set -- a b; shift 5 2>/dev/null; echo $?' 2>&1)
 +if [ "$result" != "0" ]; then
 +    pass 'shift beyond $# returns non-zero'
 +else
 +    fail 'shift beyond $# returns non-zero' "non-zero" "$result"
 +fi
++
 +# =====================================
 +section "375. ENVIRONMENT VARIABLES"
 +# =====================================
++
 +# HOME is set
 +result=$("$FORTSH_BIN" -c 'echo $HOME' 2>&1)
 +if [ -n "$result" ] && [ -d "$result" ]; then
 +    pass "HOME is set to valid directory"
 +else
 +    fail "HOME is set to valid directory" "directory" "$result"
 +fi
++
 +# PATH is set
 +result=$("$FORTSH_BIN" -c 'echo $PATH' 2>&1)
 +if [ -n "$result" ]; then
 +    pass "PATH is set"
 +else
 +    fail "PATH is set" "non-empty" "$result"
 +fi
++
 +# 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)
 +if [ "$result" = "0" ]; then
 +    pass "PATH affects command resolution"
 +else
 +    fail "PATH affects command resolution" "0" "$result"
 +fi
++
 +# Empty PATH means current directory only
 +result=$("$FORTSH_BIN" -c 'PATH=""; ls / 2>/dev/null; echo $?' 2>&1)
 +if [ "$result" != "0" ]; then
 +    pass "Empty PATH prevents finding commands"
 +else
 +    fail "Empty PATH prevents finding commands" "non-zero" "$result"
 +fi
++
 +# =====================================
 +section "376. EVAL SPECIAL CASES"
 +# =====================================
++
 +# eval with variable containing command
 +result=$("$FORTSH_BIN" -c 'cmd="echo hello"; eval "$cmd"' 2>&1)
 +if [ "$result" = "hello" ]; then
 +    pass "eval executes command in variable"
 +else
 +    fail "eval executes command in variable" "hello" "$result"
 +fi
++
 +# eval with multiple arguments
 +result=$("$FORTSH_BIN" -c 'eval echo hello world' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "eval concatenates arguments"
 +else
 +    fail "eval concatenates arguments" "hello world" "$result"
 +fi
++
 +# eval with variable expansion
 +result=$("$FORTSH_BIN" -c 'x=y; y=z; eval echo \$$x' 2>&1)
 +if [ "$result" = "z" ]; then
 +    pass "eval performs double expansion"
 +else
 +    fail "eval performs double expansion" "z" "$result"
 +fi
++
 +# eval exit status
 +result=$("$FORTSH_BIN" -c 'eval false; echo $?' 2>&1)
 +if [ "$result" = "1" ]; then
 +    pass "eval returns command exit status"
 +else
 +    fail "eval returns command exit status" "1" "$result"
 +fi
++
 +# =====================================
 +section "377. COMMAND EXECUTION MODES"
 +# =====================================
++
 +# Command with -c flag
 +result=$("$FORTSH_BIN" -c 'echo test' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "fortsh -c executes command"
 +else
 +    fail "fortsh -c executes command" "test" "$result"
 +fi
++
 +# Command with environment var
 +result=$(X=value "$FORTSH_BIN" -c 'echo $X' 2>&1)
 +if [ "$result" = "value" ]; then
 +    pass "env var passed to fortsh"
 +else
 +    fail "env var passed to fortsh" "value" "$result"
 +fi
++
 +# =====================================
 +section "378. SPECIAL BUILTIN BEHAVIORS"
 +# =====================================
++
 +# break outside loop
 +result=$("$FORTSH_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
 +    fail "break outside loop returns error status"
 +fi
++
 +# continue outside loop
 +result=$("$FORTSH_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
 +    fail "continue outside loop returns error status"
 +fi
++
 +# return outside function
 +result=$("$FORTSH_BIN" -c 'return 2>/dev/null; echo $?' 2>&1)
 +if echo "$result" | grep -qE '^[0-9]'; then
 +    pass "return outside function handled"
 +else
 +    fail "return outside function handled"
 +fi
++
 +# =====================================
 +section "379. REDIRECTION EDGE CASES"
 +# =====================================
++
 +# Redirect to /dev/null
 +result=$("$FORTSH_BIN" -c 'echo test > /dev/null; echo done' 2>&1)
 +if [ "$result" = "done" ]; then
 +    pass "redirect to /dev/null works"
 +else
 +    fail "redirect to /dev/null works" "done" "$result"
 +fi
++
 +# Redirect stderr to stdout
 +result=$("$FORTSH_BIN" -c 'echo stderr >&2' 2>&1)
 +if [ "$result" = "stderr" ]; then
 +    pass "redirect stderr to stdout"
 +else
 +    fail "redirect stderr to stdout" "stderr" "$result"
 +fi
++
 +# =====================================
 +section "380. POSITIONAL PARAMETERS EDGE CASES"
 +# =====================================
++
 +# 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)
 +if echo "$result" | grep -q "a j k"; then
 +    pass "access to \${10} and beyond"
 +else
 +    fail "access to \${10} and beyond" "a j k" "$result"
 +fi
++
 +# shift with count
 +result=$("$FORTSH_BIN" -c 'set -- a b c d e; shift 3; echo $1' 2>&1)
 +if [ "$result" = "d" ]; then
 +    pass "shift with count"
 +else
 +    fail "shift with count" "d" "$result"
 +fi
++
 +# =====================================
 +section "381. ARITHMETIC EDGE CASES"
 +# =====================================
++
 +# Negative numbers
 +result=$("$FORTSH_BIN" -c 'echo $((-5))' 2>&1)
 +if [ "$result" = "-5" ]; then
 +    pass "negative numbers in arithmetic"
 +else
 +    fail "negative numbers in arithmetic" "-5" "$result"
 +fi
++
 +# Parentheses for grouping
 +result=$("$FORTSH_BIN" -c 'echo $(( (2+3) * 4 ))' 2>&1)
 +if [ "$result" = "20" ]; then
 +    pass "parentheses in arithmetic"
 +else
 +    fail "parentheses in arithmetic" "20" "$result"
 +fi
++
 +# Comparison operators return 0/1
 +result=$("$FORTSH_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)
 +if [ "$result" = "0" ]; then
 +    pass "arithmetic comparison returns 0 for false"
 +else
 +    fail "arithmetic comparison returns 0 for false" "0" "$result"
 +fi
++
 +# =====================================
 +section "382. VARIABLE ASSIGNMENT EDGE CASES"
 +# =====================================
++
 +# Assignment with empty value
 +result=$("$FORTSH_BIN" -c 'X=; echo "[$X]"' 2>&1)
 +if [ "$result" = "[]" ]; then
 +    pass "empty variable assignment"
 +else
 +    fail "empty variable assignment" "[]" "$result"
 +fi
++
 +# Assignment with quotes
 +result=$("$FORTSH_BIN" -c 'X="hello world"; echo $X' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "quoted variable assignment"
 +else
 +    fail "quoted variable assignment" "hello world" "$result"
 +fi
++
 +# Multiple assignments on one line
 +result=$("$FORTSH_BIN" -c 'A=1 B=2 C=3; echo $A $B $C' 2>&1)
 +if [ "$result" = "1 2 3" ]; then
 +    pass "multiple assignments"
 +else
 +    fail "multiple assignments" "1 2 3" "$result"
 +fi
++
 +# =====================================
 +section "383. QUOTING EDGE CASES"
 +# =====================================
++
 +# Single quotes preserve literally
 +result=$("$FORTSH_BIN" -c "echo '\$HOME'" 2>&1)
 +if [ "$result" = '$HOME' ]; then
 +    pass "single quotes preserve dollar"
 +else
 +    fail "single quotes preserve dollar" "\$HOME" "$result"
 +fi
++
 +# Double quotes allow expansion
 +result=$("$FORTSH_BIN" -c 'X=test; echo "$X"' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "double quotes allow expansion"
 +else
 +    fail "double quotes allow expansion" "test" "$result"
 +fi
++
 +# Mixed quoting
 +result=$("$FORTSH_BIN" -c "X=val; echo 'literal'\"\$X\"'more'" 2>&1)
 +if [ "$result" = "literalvalmore" ]; then
 +    pass "mixed quoting works"
 +else
 +    fail "mixed quoting works" "literalvalmore" "$result"
 +fi
++
 +# =====================================
 +section "384. PIPELINE EDGE CASES"
 +# =====================================
++
 +# Pipeline with three stages
 +result=$("$FORTSH_BIN" -c 'echo test | cat | cat' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "three-stage pipeline"
 +else
 +    fail "three-stage pipeline" "test" "$result"
 +fi
++
 +# Pipeline with grep
 +result=$("$FORTSH_BIN" -c 'echo "hello world" | grep hello' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "pipeline with grep"
 +else
 +    fail "pipeline with grep" "hello world" "$result"
 +fi
++
 +# =====================================
 +section "385. CASE STATEMENT EDGE CASES"
 +# =====================================
++
 +# Case with wildcards
 +result=$("$FORTSH_BIN" -c 'x=hello; case $x in h*) echo match;; esac' 2>&1)
 +if [ "$result" = "match" ]; then
 +    pass "case with wildcard pattern"
 +else
 +    fail "case with wildcard pattern" "match" "$result"
 +fi
++
 +# Case with multiple patterns
 +result=$("$FORTSH_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
 +    fail "case with multiple patterns" "abc" "$result"
 +fi
++
 +# Case with default
 +result=$("$FORTSH_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
 +    fail "case with default pattern" "default" "$result"
 +fi
++
 +# =====================================
 +section "386. LOOP EDGE CASES"
 +# =====================================
++
 +# 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)
 +expected="1
 +2"
 +if [ "$result" = "$expected" ]; then
 +    pass "for loop with break"
 +else
 +    fail "for loop with break"
 +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)
 +if echo "$result" | grep -q "1" && echo "$result" | grep -q "4" && ! echo "$result" | grep -q "3"; then
 +    pass "for loop with continue"
 +else
 +    fail "for loop with continue"
 +fi
++
 +# =====================================
 +section "387. SUBSHELL EDGE CASES"
 +# =====================================
++
 +# Subshell variable isolation
 +result=$("$FORTSH_BIN" -c 'X=outer; (X=inner; echo $X); echo $X' 2>&1)
 +expected="inner
 +outer"
 +if [ "$result" = "$expected" ]; then
 +    pass "subshell variable isolation"
 +else
 +    fail "subshell variable isolation"
 +fi
++
 +# Subshell exit status
 +result=$("$FORTSH_BIN" -c '(exit 42); echo $?' 2>&1)
 +if [ "$result" = "42" ]; then
 +    pass "subshell exit status captured"
 +else
 +    fail "subshell exit status captured" "42" "$result"
 +fi
++
 +# =====================================
 +section "388. FUNCTION EDGE CASES"
 +# =====================================
++
 +# Function with local-like behavior (via subshell)
 +result=$("$FORTSH_BIN" -c 'X=global; f() { (X=local; echo $X); }; f; echo $X' 2>&1)
 +expected="local
 +global"
 +if [ "$result" = "$expected" ]; then
 +    pass "function with subshell for local vars"
 +else
 +    fail "function with subshell for local vars"
 +fi
++
 +# Recursive function
 +result=$("$FORTSH_BIN" -c 'count() { if [ $1 -gt 0 ]; then echo $1; count $(($1-1)); fi; }; count 3' 2>&1)
 +expected="3
 +2
 +1"
 +if [ "$result" = "$expected" ]; then
 +    pass "recursive function"
 +else
 +    fail "recursive function"
 +fi
++
 +# =====================================
 +section "389. HERE DOCUMENT EDGE CASES"
 +# =====================================
++
 +# Heredoc with variable expansion
 +result=$("$FORTSH_BIN" -c 'X=value; cat <<EOF
 +$X
 +EOF' 2>&1)
 +if [ "$result" = "value" ]; then
 +    pass "heredoc variable expansion"
 +else
 +    fail "heredoc variable expansion" "value" "$result"
 +fi
++
 +# Quoted heredoc (no expansion)
 +result=$("$FORTSH_BIN" -c 'cat <<'\''EOF'\''
 +$VAR
 +EOF' 2>&1)
 +if [ "$result" = '$VAR' ]; then
 +    pass "quoted heredoc no expansion"
 +else
 +    fail "quoted heredoc no expansion" "\$VAR" "$result"
 +fi
++
 +# =====================================
 +section "390. COMMAND SUBSTITUTION EDGE CASES"
 +# =====================================
++
 +# Nested command substitution
 +result=$("$FORTSH_BIN" -c 'echo $(echo $(echo nested))' 2>&1)
 +if [ "$result" = "nested" ]; then
 +    pass "nested command substitution"
 +else
 +    fail "nested command substitution" "nested" "$result"
 +fi
++
 +# Command substitution with quotes
 +result=$("$FORTSH_BIN" -c 'echo "$(echo "hello world")"' 2>&1)
 +if [ "$result" = "hello world" ]; then
 +    pass "command substitution with quotes"
 +else
 +    fail "command substitution with quotes" "hello world" "$result"
 +fi
++
 +# Backtick substitution
 +result=$("$FORTSH_BIN" -c 'echo `echo backtick`' 2>&1)
 +if [ "$result" = "backtick" ]; then
 +    pass "backtick command substitution"
 +else
 +    fail "backtick command substitution" "backtick" "$result"
 +fi
++
 +# =====================================
 +section "391. EXPR COMMAND"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "6" ]; then
 +    pass "expr subtraction"
 +else
 +    fail "expr subtraction" "6" "$result"
 +fi
++
 +result=$("$FORTSH_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)
 +if [ "$result" = "5" ]; then
 +    pass "expr division"
 +else
 +    fail "expr division" "5" "$result"
 +fi
++
 +# =====================================
 +section "392. TEST COMMAND VARIATIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "yes" ]; then
 +    pass "test string equal"
 +else
 +    fail "test string equal" "yes" "$result"
 +fi
++
 +# =====================================
 +section "393. BASENAME AND DIRNAME SIMULATION"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +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)
 +if [ "$result" = "file" ]; then
 +    pass "remove all extensions"
 +else
 +    fail "remove all extensions" "file" "$result"
 +fi
++
 +# =====================================
 +section "394. COMPLEX PIPELINES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "test" ]; then
 +    pass "triple cat pipeline"
 +else
 +    fail "triple cat pipeline" "test" "$result"
 +fi
++
 +# =====================================
 +section "395. COMMAND GROUPING"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +expected=$(printf "2\n2")
 +if [ "$result" = "$expected" ]; then
 +    pass "brace group modifies parent var"
 +else
 +    fail "brace group modifies parent var"
 +fi
++
 +# =====================================
 +section "396. WORD EXPANSION ORDER"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "1" ]; then
 +    pass "tilde expands to home"
 +else
 +    fail "tilde expands to home" "1" "$result"
 +fi
++
 +# =====================================
 +section "397. SIGNAL NAMES"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" -ge 1 ]; then
 +    pass "kill -l shows TERM"
 +else
 +    fail "kill -l shows TERM"
 +fi
++
 +# =====================================
 +section "398. EXEC WITH FD"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'exec 3>&1; echo test >&3; exec 3>&-' 2>&1)
 +if [ "$result" = "test" ]; then
 +    pass "exec fd redirect"
 +else
 +    fail "exec fd redirect" "test" "$result"
 +fi
++
 +# =====================================
 +section "399. COMPLEX FUNCTIONS"
 +# =====================================
++
 +result=$("$FORTSH_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)
 +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)
 +if [ "$result" = "Hello, World!" ]; then
 +    pass "function with string interpolation"
 +else
 +    fail "function with string interpolation" "Hello, World!" "$result"
 +fi
++
 +# =====================================
 +section "400. ADVANCED REDIRECTIONS"
 +# =====================================
++
 +result=$("$FORTSH_BIN" -c 'echo out; echo err >&2' 2>&1)
 +expected=$(printf "out\nerr")
 +if [ "$result" = "$expected" ]; then
 +    pass "stdout and stderr"
 +else
 +    fail "stdout and stderr"
 +fi
++
 +result=$("$FORTSH_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
 +    fail "redirect stderr to stdout in pipeline" "2" "$result"
 +fi
++
 +# =====================================
 +# Summary
 +# =====================================
 +printf "\n"
 +printf "${BLUE}==========================================\n"
 +printf "POSIX Special Features Test Summary\n"
 +printf "==========================================${NC}\n"
 +printf "Passed:  ${GREEN}%d${NC}\n" "$PASSED"
 +printf "Failed:  ${RED}%d${NC}\n" "$FAILED"
 +printf "Skipped: ${YELLOW}%d${NC}\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
++
 +if [ -n "$FAILED_TESTS_LIST" ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_compliance_test.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Test Suite for fortsh
 +# =====================================
 +# Tests compliance with POSIX shell specification
 +# Uses /bin/sh for comparison (typically dash or bash in POSIX mode)
++
 +# Note: Using only POSIX-compliant constructs in this script
 +# No bash-isms allowed!
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-test]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s - %s\n" "$1" "$2"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "3. POSIX PARAMETER EXPANSION"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n"
 +    printf "${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Helper function to run command in both shells and compare
 +compare_posix_output() {
 +    test_name="$1"
 +    command="$2"
 +    posix_file="/tmp/posix_comp_$$_posix"
 +    fortsh_file="/tmp/posix_comp_$$_fortsh"
++
 +    # Run in POSIX shell (sh)
 +    "$BASH_REF" -c "$command" > "$posix_file" 2>&1 || true
++
 +    # Run in fortsh
 +    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true
++
 +    # Compare outputs
 +    if diff -q "$posix_file" "$fortsh_file" > /dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$(cat "$posix_file")" "$(cat "$fortsh_file")"
 +    fi
++
 +    rm -f "$posix_file" "$fortsh_file"
 +}
++
 +# Helper function to compare exit codes
 +compare_posix_exit_code() {
 +    test_name="$1"
 +    command="$2"
++
 +    "$BASH_REF" -c "$command" > /dev/null 2>&1
 +    posix_exit=$?
++
 +    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1
 +    fortsh_exit=$?
++
 +    if [ "$posix_exit" -eq "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "exit=$posix_exit" "exit=$fortsh_exit"
 +    fi
 +}
++
 +# Cleanup
 +cleanup() {
 +    rm -f /tmp/posix_comp_$$_* 2>/dev/null
 +    rm -f /tmp/posix_test_* 2>/dev/null
 +}
 +trap cleanup EXIT INT TERM
++
 +section "1. POSIX BASIC COMMANDS"
++
 +compare_posix_output "echo simple" "echo hello"
 +compare_posix_output "echo with args" "echo one two three"
 +compare_posix_output "printf basic" "printf 'test\n'"
 +compare_posix_output "printf with args" "printf '%s %d\n' hello 42"
++
 +section "2. POSIX VARIABLE EXPANSION"
++
 +compare_posix_output "simple variable" "VAR=test; echo \$VAR"
 +compare_posix_output "variable in quotes" 'VAR=test; echo "$VAR"'
 +compare_posix_output "multiple vars" "A=hello; B=world; echo \$A \$B"
 +compare_posix_output "undefined variable" "echo \$UNDEFINED_VAR_XYZ_987"
++
 +section "3. POSIX PARAMETER EXPANSION"
++
 +# Basic parameter expansion
 +compare_posix_output "default value" 'echo "${UNSET:-default}"'
 +compare_posix_output "assign default" 'UNSET=; echo "${UNSET:=assigned}"; echo $UNSET'
 +compare_posix_output "error if unset" 'echo "${VAR:+alternative}"'
 +compare_posix_output "string length" 'VAR=hello; echo "${#VAR}"'
++
 +# Prefix removal (# and ##)
 +compare_posix_output "remove shortest prefix" 'VAR=foo.bar.baz; echo "${VAR#*.}"'
 +compare_posix_output "remove longest prefix" 'VAR=foo.bar.baz; echo "${VAR##*.}"'
 +compare_posix_output "prefix no match" 'VAR=hello; echo "${VAR#x*}"'
 +compare_posix_output "prefix remove slash" 'VAR=/usr/local/bin; echo "${VAR#/*/}"'
++
 +# Suffix removal (% and %%)
 +compare_posix_output "remove shortest suffix" 'VAR=foo.bar.baz; echo "${VAR%.*}"'
 +compare_posix_output "remove longest suffix" 'VAR=foo.bar.baz; echo "${VAR%%.*}"'
 +compare_posix_output "suffix no match" 'VAR=hello; echo "${VAR%x*}"'
 +compare_posix_output "suffix remove extension" 'VAR=file.tar.gz; echo "${VAR%.gz}"'
++
 +section "4. POSIX COMMAND SUBSTITUTION"
++
 +compare_posix_output "backtick substitution" 'echo `echo test`'
 +compare_posix_output "dollar paren substitution" "echo \$(echo test)"
 +compare_posix_output "nested substitution" "echo \$(echo \$(echo nested))"
++
 +section "5. POSIX ARITHMETIC"
++
 +# POSIX arithmetic uses expr or $(( ))
 +compare_posix_output "expr addition" "expr 5 + 3"
 +compare_posix_output "expr multiplication" "expr 4 \* 3"
 +compare_posix_output "expr division" "expr 15 / 3"
++
 +section "6. POSIX REDIRECTION"
++
 +compare_posix_output "output redirect" "echo test > /tmp/posix_test_out; cat /tmp/posix_test_out"
 +compare_posix_output "append redirect" "echo line1 > /tmp/posix_test_app; echo line2 >> /tmp/posix_test_app; wc -l < /tmp/posix_test_app"
 +compare_posix_output "input redirect" "echo input > /tmp/posix_test_in; cat < /tmp/posix_test_in"
 +compare_posix_output "stderr redirect" "ls /nonexistent 2>&1 | grep -c 'cannot access\|No such\|not found'"
++
 +section "7. POSIX PIPELINES"
++
 +compare_posix_output "simple pipe" "echo hello | cat"
 +compare_posix_output "two-stage pipe" "echo test | cat | tr t T"
 +compare_posix_output "pipe with filter" "printf 'a\nb\nc\n' | grep b"
++
 +section "8. POSIX TEST COMMAND"
++
 +compare_posix_exit_code "test -f file" "touch /tmp/posix_test_file && test -f /tmp/posix_test_file"
 +compare_posix_exit_code "test -d directory" "test -d /tmp"
 +compare_posix_exit_code "test -n nonempty" "test -n 'hello'"
 +compare_posix_exit_code "test -z empty" "test -z ''"
 +compare_posix_exit_code "test string =" "test 'hello' = 'hello'"
 +compare_posix_exit_code "test string !=" "test 'hello' != 'world'"
 +compare_posix_exit_code "test number -eq" "test 5 -eq 5"
 +compare_posix_exit_code "test number -ne" "test 5 -ne 3"
 +compare_posix_exit_code "test number -gt" "test 5 -gt 3"
 +compare_posix_exit_code "test number -ge" "test 5 -ge 5"
 +compare_posix_exit_code "test number -lt" "test 3 -lt 5"
 +compare_posix_exit_code "test number -le" "test 3 -le 3"
++
 +section "9. POSIX CONDITIONALS"
++
 +compare_posix_output "if true" "if true; then echo yes; fi"
 +compare_posix_output "if false else" "if false; then echo no; else echo yes; fi"
 +compare_posix_output "if-elif-else" "X=2; if [ \$X -eq 1 ]; then echo one; elif [ \$X -eq 2 ]; then echo two; else echo other; fi"
++
 +section "10. POSIX LOOPS"
++
 +compare_posix_output "for loop" "for i in a b c; do echo \$i; done"
 +compare_posix_output "while loop" "i=3; while [ \$i -gt 0 ]; do echo \$i; i=\$((i - 1)); done"
 +compare_posix_output "until loop" "i=1; until [ \$i -gt 3 ]; do echo \$i; i=\$((i + 1)); done"
++
 +section "11. POSIX CASE STATEMENT"
++
 +compare_posix_output "case exact match" "x=2; case \$x in 1) echo one;; 2) echo two;; esac"
 +compare_posix_output "case pattern match" "x=hello; case \$x in h*) echo h_prefix;; esac"
 +compare_posix_output "case default" "x=z; case \$x in a) echo a;; b) echo b;; *) echo default;; esac"
 +compare_posix_output "case multiple patterns" "x=b; case \$x in a|b|c) echo abc;; *) echo other;; esac"
++
 +section "12. POSIX FUNCTIONS"
++
 +compare_posix_output "simple function" "func() { echo hello; }; func"
 +compare_posix_output "function with args" "func() { echo \$1 \$2; }; func foo bar"
 +compare_posix_output "function return" "func() { return 42; }; func; echo \$?"
 +compare_posix_output "function \$# args" "func() { echo \$#; }; func a b c"
++
 +section "13. POSIX SPECIAL VARIABLES"
++
 +compare_posix_output "\$? exit status" "true; echo \$?"
 +compare_posix_output "\$? after false" "false; echo \$?"
 +compare_posix_output "\$# argument count" "set -- a b c; echo \$#"
 +compare_posix_output "\$@ all arguments" "set -- a b c; echo \$@"
 +compare_posix_output "\$* all arguments" "set -- a b c; echo \$*"
 +compare_posix_output "\$0 script name" "echo \$0 | grep -c sh"
++
 +section "14. POSIX LOGICAL OPERATORS"
++
 +compare_posix_exit_code "true && true" "true && true"
 +compare_posix_exit_code "true && false" "true && false"
 +compare_posix_exit_code "false || true" "false || true"
 +compare_posix_exit_code "false || false" "false || false"
 +compare_posix_output "command && echo" "true && echo success"
 +compare_posix_output "command || echo" "false || echo fallback"
 +compare_posix_output "! negation" "! false && echo negated"
++
 +section "15. POSIX QUOTING"
++
 +compare_posix_output "single quote literal" "echo '\$VAR'"
 +compare_posix_output "double quote expand" 'VAR=test; echo "$VAR"'
 +compare_posix_output "escape in double" 'echo "test\$var"'
 +compare_posix_output "backslash escape" 'echo test\ word'
++
 +section "16. POSIX SUBSHELLS"
++
 +compare_posix_output "subshell grouping" "(echo a; echo b) | wc -l"
 +compare_posix_output "subshell var isolation" "(VAR=inner; echo \$VAR); echo \$VAR"
++
 +section "17. POSIX COMPOUND COMMANDS"
++
 +compare_posix_output "command grouping {}" "{ echo a; echo b; } | wc -l"
 +compare_posix_output "command list ;" "echo a; echo b"
++
 +section "18. POSIX HERE DOCUMENTS"
++
 +compare_posix_output "simple heredoc" "cat <<EOF
 +line1
 +line2
 +EOF"
++
 +compare_posix_output "heredoc with vars" "VAR=test; cat <<EOF
 +value=\$VAR
 +EOF"
++
 +compare_posix_output "quoted heredoc" "cat <<'EOF'
 +\$VAR
 +EOF"
++
 +section "19. POSIX WORD EXPANSION ORDER"
++
 +# POSIX specifies: tilde, parameter, command subst, arithmetic, field splitting, pathname, quote removal
 +compare_posix_output "expansion order" "VAR='a b'; echo \$VAR"
 +compare_posix_output "quoted expansion" 'VAR="a b"; echo "$VAR"'
++
 +section "20. POSIX PATHNAME EXPANSION (GLOBBING)"
++
 +# Setup test files
 +mkdir -p /tmp/posix_test_glob
 +touch /tmp/posix_test_glob/a.txt /tmp/posix_test_glob/b.txt /tmp/posix_test_glob/c.dat
++
 +compare_posix_output "glob * pattern" "ls /tmp/posix_test_glob/*.txt 2>/dev/null | wc -l"
 +compare_posix_output "glob ? pattern" "ls /tmp/posix_test_glob/?.txt 2>/dev/null | wc -l"
 +compare_posix_output "glob [abc] pattern" "ls /tmp/posix_test_glob/[ab].txt 2>/dev/null | wc -l"
++
 +section "21. POSIX FIELD SPLITTING (IFS)"
++
 +compare_posix_output "default IFS" "VAR='a b c'; set -- \$VAR; echo \$#"
 +compare_posix_output "custom IFS" "IFS=:; VAR='a:b:c'; set -- \$VAR; echo \$1"
++
 +section "22. POSIX EXIT STATUS"
++
 +compare_posix_exit_code "true exit status" "true"
 +compare_posix_exit_code "false exit status" "false"
 +compare_posix_exit_code "command not found" "nonexistent_command_xyz 2>/dev/null"
 +compare_posix_exit_code "return from function" "func() { return 3; }; func"
++
 +section "23. POSIX SET BUILTIN"
++
 +compare_posix_output "set positional" "set -- a b c; echo \$1 \$2 \$3"
 +compare_posix_output "set shift" "set -- a b c; shift; echo \$1"
 +compare_posix_output "set shift n" "set -- a b c d; shift 2; echo \$1"
++
 +section "24. POSIX EXPORT"
++
 +compare_posix_output "export variable" "export VAR=test; sh -c 'echo \$VAR'"
++
 +section "25. POSIX READONLY"
++
 +compare_posix_exit_code "readonly assignment" "readonly VAR=test; VAR=new 2>/dev/null"
++
 +section "26. POSIX UNSET"
++
 +compare_posix_output "unset variable" "VAR=test; unset VAR; echo \${VAR:-empty}"
 +compare_posix_output "unset nonexistent" "unset NONEXISTENT_VAR; echo ok"
 +compare_posix_exit_code "unset readonly fails" "readonly X=1; unset X 2>/dev/null"
 +compare_posix_output "unset function" "f() { echo hi; }; unset -f f; f 2>/dev/null || echo gone"
++
 +section "27. POSIX EVAL"
++
 +compare_posix_output "eval simple" "eval 'echo hello'"
 +compare_posix_output "eval variable" "CMD='echo test'; eval \$CMD"
 +compare_posix_output "eval assignment" "eval 'X=5'; echo \$X"
 +compare_posix_output "eval command subst" "eval 'echo \$(echo nested)'"
 +compare_posix_output "eval with semicolon" "eval 'echo a; echo b'"
++
 +section "28. POSIX EXEC"
++
 +compare_posix_output "exec replaces shell" "exec echo done"
 +compare_posix_exit_code "exec nonexistent" "exec /nonexistent/command 2>/dev/null"
++
 +section "29. POSIX COLON BUILTIN"
++
 +compare_posix_output "colon no-op" ": ; echo ok"
 +compare_posix_exit_code "colon exit status" ":"
 +compare_posix_output "colon with args" ": arg1 arg2; echo ok"
 +compare_posix_output "colon in if" "if :; then echo yes; fi"
++
 +section "30. POSIX DOT/SOURCE"
++
 +# Create temp script
 +echo 'SOURCED_VAR=from_source' > /tmp/posix_test_source.sh
 +compare_posix_output "dot source script" ". /tmp/posix_test_source.sh; echo \$SOURCED_VAR"
 +compare_posix_exit_code "dot nonexistent" ". /nonexistent_file 2>/dev/null"
++
 +section "31. POSIX CD AND PWD"
++
 +compare_posix_output "cd and pwd" "cd /tmp && pwd"
 +compare_posix_output "cd - returns to OLDPWD" "cd /tmp; cd /; cd -"
 +compare_posix_exit_code "cd nonexistent" "cd /nonexistent_dir 2>/dev/null"
 +compare_posix_output "pwd builtin" "pwd | grep -c /"
++
 +section "32. POSIX UMASK"
++
 +compare_posix_output "umask display" "umask | grep -E '^[0-9]{3,4}\$'"
 +compare_posix_output "umask set and restore" "OLD=\$(umask); umask 077; umask \$OLD"
++
 +section "33. POSIX WAIT"
++
 +compare_posix_output "wait for background" "sleep 0.1 & wait; echo done"
 +compare_posix_exit_code "wait no jobs" "wait"
++
 +section "34. POSIX TIMES"
++
 +# times is optional but common
 +# times output contains variable timing values, so just verify format
 +_times_out=$("$FORTSH_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
 +    fail "times output exists" "NmN.NNNs NmN.NNNs" "$_times_out"
 +fi
++
 +section "35. POSIX BREAK AND CONTINUE"
++
 +compare_posix_output "break in for" "for i in 1 2 3 4 5; do [ \$i -eq 3 ] && break; echo \$i; done"
 +compare_posix_output "continue in for" "for i in 1 2 3 4 5; do [ \$i -eq 3 ] && continue; echo \$i; done"
 +compare_posix_output "break in while" "i=0; while [ \$i -lt 10 ]; do i=\$((i+1)); [ \$i -eq 3 ] && break; echo \$i; done"
 +compare_posix_output "break 2 nested" "for i in a b; do for j in 1 2 3; do [ \$j -eq 2 ] && break 2; echo \$i\$j; done; done"
 +compare_posix_output "continue 2 nested" "for i in a b; do for j in 1 2 3; do [ \$j -eq 2 ] && continue 2; echo \$i\$j; done; done"
++
 +section "36. POSIX SIGNAL HANDLING"
++
 +# Note: trap output may vary by environment - test exit code
 +compare_posix_exit_code "trap list" "trap >/dev/null 2>&1"
 +compare_posix_output "trap on exit" "trap 'echo exiting' EXIT; exit 0"
 +compare_posix_exit_code "trap reset" "trap - INT"
++
 +section "37. POSIX BACKGROUND AND JOBS"
++
 +compare_posix_output "background job" "sleep 0.1 & echo started; wait"
 +# Note: $! returns different PIDs in each shell, so we check both output valid PIDs (exit code)
 +compare_posix_exit_code "\$! last background pid" "sleep 0.1 & echo \$! | grep -qE '^[0-9]+\$'"
++
 +section "38. POSIX ALIAS"
++
 +compare_posix_output "alias definition" "alias ll='ls -l'; alias | grep ll"
 +compare_posix_output "unalias" "alias x='echo test'; unalias x; alias | grep -c 'x=' || echo 0"
++
 +section "39. POSIX COMMAND SEARCH"
++
 +compare_posix_output "type builtin" "type echo | grep -c builtin"
 +compare_posix_output "command -v" "command -v echo | grep -c echo"
 +compare_posix_exit_code "command not found" "command -v nonexistent_xyz 2>/dev/null"
++
 +section "40. POSIX COMPLEX EXPANSIONS"
++
 +compare_posix_output "nested parameter expansion" 'A=hello; B=A; eval "echo \$$B"'
 +compare_posix_output "expansion in assignment" 'X=$(echo test); echo $X'
 +compare_posix_output "arithmetic in expansion" 'echo $((2 + 3 * 4))'
 +compare_posix_output "multiple substitutions" 'A=1; B=2; echo $(echo $A) $(echo $B)'
++
 +# Summary
 +printf "\n"
 +printf "==========================================\n"
 +printf "POSIX COMPLIANCE TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +if [ $((PASSED + FAILED)) -gt 0 ]; then
 +    PASS_RATE=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%%\n" "$PASS_RATE"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL POSIX COMPLIANCE TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_compliance_untested.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance - Previously Untested Features
 +# =====================================
 +# Tests for POSIX features that are implemented but lack test coverage
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[posix-untested]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +# Test result trackers
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +skip() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${YELLOW}⊘ SKIP${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    SKIPPED=$((SKIPPED + 1))
 +}
++
 +section() {
 +    # Extract section number from header like "131. COMMAND BUILTIN"
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    printf "\n${BLUE}==========================================\n"
 +    printf "%s\n" "$1"
 +    printf "==========================================${NC}\n"
 +}
++
 +# Compare output between sh and fortsh
 +compare_posix_output() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    # Run with POSIX sh
 +    posix_output=$(FORTSH_RC_FILE=/dev/null "$BASH_REF" -c "$test_cmd" 2>&1)
 +    posix_exit=$?
++
 +    # Run with fortsh
 +    fortsh_output=$(FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" 2>&1)
 +    fortsh_exit=$?
++
 +    # Compare outputs
 +    if [ "$posix_output" = "$fortsh_output" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$posix_output" "$fortsh_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]*: //'
 +}
++
 +# Compare error output, normalizing line number differences
 +compare_posix_error() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    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_exit=$?
++
 +    posix_norm=$(normalize_error "$posix_output")
 +    fortsh_norm=$(normalize_error "$fortsh_output")
++
 +    if [ "$posix_norm" = "$fortsh_norm" ] && [ "$posix_exit" = "$fortsh_exit" ]; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "$posix_output" "$fortsh_output"
 +    fi
 +}
++
 +# Test that fortsh accepts an option/command without error
 +test_accepts() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    if FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "should succeed" "failed or not implemented"
 +    fi
 +}
++
 +# Test that command fails as expected
 +test_fails() {
 +    test_name="$1"
 +    test_cmd="$2"
++
 +    if ! FORTSH_RC_FILE=/dev/null "$FORTSH_BIN" -c "$test_cmd" >/dev/null 2>&1; then
 +        pass "$test_name"
 +    else
 +        fail "$test_name" "should fail" "succeeded unexpectedly"
 +    fi
 +}
++
 +# =====================================
 +# TESTS START HERE
 +# =====================================
++
 +section "131. COMMAND BUILTIN - PATH SEARCH"
++
 +compare_posix_output "command -v ls" 'command -v ls >/dev/null && echo found'
 +compare_posix_output "command -v nonexistent" 'command -v nonexistent >/dev/null || echo notfound'
 +test_accepts "command -p ls" 'command -p ls / >/dev/null'
 +compare_posix_output "command without options" 'command echo test'
++
 +section "132. MULTI-FD REDIRECTIONS"
++
 +# Create test file
 +compare_posix_output "fd 3 redirect write" 'exec 3>/tmp/posix_fd3.txt; echo test >&3; exec 3>&-; cat /tmp/posix_fd3.txt; rm /tmp/posix_fd3.txt'
 +compare_posix_output "fd 4 redirect read" 'echo data > /tmp/posix_fd4.txt; exec 4</tmp/posix_fd4.txt; read line <&4; echo $line; exec 4<&-; rm /tmp/posix_fd4.txt'
 +compare_posix_output "fd duplication" 'exec 5>&1; echo stdout >&5; exec 5>&-'
 +compare_posix_output "fd 3 and 4 together" 'exec 3>/tmp/posix_3.txt 4>/tmp/posix_4.txt; echo a >&3; echo b >&4; exec 3>&- 4>&-; cat /tmp/posix_3.txt /tmp/posix_4.txt; rm /tmp/posix_3.txt /tmp/posix_4.txt'
++
 +section "133. EXEC WITH SHELL REDIRECTIONS"
++
 +# Note: These redirect the shell itself, not just one command
 +# Save stdout to FD 3, redirect, write, restore, then cat (otherwise cat hangs on file still open for writing)
 +compare_posix_output "exec redirect stdout" 'exec 3>&1; exec >/tmp/posix_exec_out.txt; echo redirected; exec >&3; cat /tmp/posix_exec_out.txt; rm /tmp/posix_exec_out.txt'
 +compare_posix_output "exec redirect stdin" 'echo testdata > /tmp/posix_exec_in.txt; exec </tmp/posix_exec_in.txt; read data; echo $data; rm /tmp/posix_exec_in.txt'
++
 +section "134. SET OPTION INTERACTIONS"
++
 +compare_posix_output "set -e with true" 'set -e; true; echo ok'
 +compare_posix_output "set -u with unset var" 'set -u; echo ${UNSET_VAR:-default}'
 +compare_posix_output "set -C noclobber" 'set -C; echo test > /tmp/posix_clobber.txt; echo ok; rm /tmp/posix_clobber.txt'
 +compare_posix_output "set -C override with >|" 'set -C; echo test > /tmp/posix_clobber2.txt; echo override >| /tmp/posix_clobber2.txt; cat /tmp/posix_clobber2.txt; rm /tmp/posix_clobber2.txt'
++
 +section "135. SPECIAL BUILTIN ERROR HANDLING"
++
 +# POSIX: Special builtins must exit non-interactive shell on error
 +# Testing with subshells to avoid killing the test script
++
 +compare_posix_error "readonly error exits" '(readonly VAR=1; VAR=2 2>/dev/null; echo should not print) || echo exited'
 +compare_posix_output "export invalid" '(export 123INVALID=value 2>/dev/null; echo should not print) || echo exited'
 +compare_posix_output "set invalid option" '(set -@ 2>/dev/null; echo should not print) || echo exited'
++
 +section "136. ULIMIT TESTS"
++
 +test_accepts "ulimit display" 'ulimit'
 +test_accepts "ulimit -a all" 'ulimit -a >/dev/null'
 +test_accepts "ulimit -n files" 'ulimit -n >/dev/null'
 +test_accepts "ulimit -s stack" 'ulimit -s >/dev/null 2>&1'
++
 +section "137. NESTED PARAMETER EXPANSION"
++
 +compare_posix_output "nested default" 'unset A B; echo ${A:-${B:-default}}'
 +compare_posix_output "nested with set var" 'A=inner; unset B; echo ${B:-${A}}'
 +compare_posix_output "double nested" 'unset A B C; echo ${A:-${B:-${C:-triple}}}'
++
 +section "138. PARAMETER LENGTH EDGE CASES"
++
 +compare_posix_output "length of $@" 'set -- a b c; echo ${#@}'
 +compare_posix_output "length of $*" 'set -- a b c; echo ${#*}'
 +compare_posix_output "length of empty" 'VAR=; echo ${#VAR}'
 +compare_posix_output "length of unset" 'unset VAR; echo ${#VAR}'
++
 +section "139. QUOTING EDGE CASES"
++
 +compare_posix_output "empty double quotes" 'VAR=""; echo x${VAR}y'
 +compare_posix_output "empty single quotes" "VAR=''; echo x\${VAR}y"
 +compare_posix_output "adjacent quotes concat" 'echo "a"b"c"'
 +compare_posix_output "quote in quote" 'echo "it'\''s"'
++
 +section "140. BACKSLASH NEWLINE CONTINUATION"
++
 +compare_posix_output "line continuation in string" 'echo "test\
 +continuation"'
 +compare_posix_output "line continuation in command" 'ec\
 +ho test'
++
 +section "141. COMMENT IN COMMAND SUBSTITUTION"
++
 +compare_posix_output "comment in subshell" '$(# this is a comment
 +echo test)'
 +compare_posix_output "comment in backtick" '`# comment
 +echo test`'
++
 +section "142. REDIRECTION EDGE CASES"
++
 +compare_posix_output "close stdin" 'cat <&- 2>&1 | head -1'
 +compare_posix_error "close stdout" 'echo test >&- 2>&1'
 +compare_posix_output "read/write mode" 'echo data > /tmp/posix_rw.txt; cat <> /tmp/posix_rw.txt; rm /tmp/posix_rw.txt'
++
 +section "143. ERROR HANDLING EDGE CASES"
++
 +test_fails "assign to positional param" '$1=value 2>/dev/null'
 +test_fails "readonly reassign" 'readonly VAR=1; VAR=2 2>/dev/null'
 +# Test that execution continues after arithmetic error
 +# Check that "continued" appears in the output (error format may vary)
 +test_accepts "division by zero" 'echo $((5/0)) | cat; echo continued 2>&1 | grep -q continued'
++
 +section "144. SET -n (NOEXEC) TESTING"
++
 +# This tests if set -n is implemented
 +compare_posix_output "set -n parse only" 'set -n; echo "should not execute"; false' || skip "set -n not implemented"
++
 +section "145. SET -m (MONITOR) TESTING"
++
 +test_accepts "set -m monitor mode" 'set -m; set +m'
 +compare_posix_output "set -m doesn't affect output" 'set -m; echo test; set +m'
++
 +# =====================================
 +# SUMMARY
 +# =====================================
++
 +printf "\n==========================================\n"
 +printf "UNTESTED FEATURES TEST RESULTS ${TEST_PREFIX}\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "${YELLOW}Skipped:${NC} %d\n" "$SKIPPED"
 +printf "Total:   %d\n" "$((PASSED + FAILED + SKIPPED))"
 +printf "==========================================\n"
++
 +# Calculate pass rate
 +if [ "$((PASSED + FAILED))" -gt 0 ]; then
 +    pass_rate=$((PASSED * 100 / (PASSED + FAILED)))
 +    printf "Pass rate: %d%%\n" "$pass_rate"
 +fi
++
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n"
 +    printf "%b" "$FAILED_TESTS_LIST"
 +    printf "==========================================\n"
 +fi
++
 +if [ "$FAILED" -eq 0 ]; then
 +    printf "${GREEN}ALL UNTESTED FEATURES TESTS PASSED!${NC} ✓\n"
 +    exit 0
 +else
 +    printf "${RED}SOME TESTS FAILED${NC} ✗\n"
 +    exit 1
 +fi

suites/posix/posix_gaps_arithmetic.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Arithmetic Gap Tests
 +# =====================================
 +# Tests for POSIX arithmetic expansion
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-arithmetic]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    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=$?
 +    if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
 +}
++
 +# ============================================================================
 +# ARITHMETIC TESTS
 +# ============================================================================
++
 +section "1. BASIC OPERATORS"
 +compare_posix_output "add" 'echo $((5+3))'
 +compare_posix_output "sub" 'echo $((5-3))'
 +compare_posix_output "mul" 'echo $((5*3))'
 +compare_posix_output "div" 'echo $((15/3))'
 +compare_posix_output "mod" 'echo $((17%5))'
 +compare_posix_output "neg" 'echo $((-5))'
++
 +section "2. SPACING"
 +compare_posix_output "with spaces" 'echo $(( 1 + 2 ))'
 +compare_posix_output "mixed spacing" 'echo $(( 5 +3 ))'
++
 +section "3. COMPARISONS"
 +compare_posix_output "lt" 'echo $((3<5))'
 +compare_posix_output "gt" 'echo $((5>3))'
 +compare_posix_output "le" 'echo $((5<=5))'
 +compare_posix_output "ge" 'echo $((5>=5))'
 +compare_posix_output "eq" 'echo $((5==5))'
 +compare_posix_output "ne" 'echo $((5!=3))'
++
 +section "4. LOGICAL"
 +compare_posix_output "and" 'echo $((1&&1))'
 +compare_posix_output "or" 'echo $((0||1))'
 +compare_posix_output "not" 'echo $((!0))'
++
 +section "5. BITWISE"
 +compare_posix_output "band" 'echo $((12&10))'
 +compare_posix_output "bor" 'echo $((12|10))'
 +compare_posix_output "bxor" 'echo $((12^10))'
 +compare_posix_output "lshift" 'echo $((1<<4))'
 +compare_posix_output "rshift" 'echo $((16>>2))'
++
 +section "6. TERNARY"
 +compare_posix_output "ternary t" 'echo $((1?10:20))'
 +compare_posix_output "ternary f" 'echo $((0?10:20))'
 +compare_posix_output "ternary expr" 'echo $((5>3?1:0))'
++
 +section "7. ASSIGNMENT OPS"
 +compare_posix_output "pluseq" 'x=5; echo $((x+=3))'
 +compare_posix_output "minuseq" 'x=5; echo $((x-=3))'
 +compare_posix_output "muleq" 'x=5; echo $((x*=3))'
 +compare_posix_output "diveq" 'x=15; echo $((x/=3))'
++
 +section "8. PRECEDENCE"
 +compare_posix_output "mul before add" 'echo $((2+3*4))'
 +compare_posix_output "parens override" 'echo $(((2+3)*4))'
 +compare_posix_output "div add" 'echo $((10/2+3))'
 +compare_posix_output "nested parens" 'echo $(((2 + 3) * (4 + 5)))'
++
 +section "9. VARIABLES"
 +compare_posix_output "var simple" 'x=5; echo $((x))'
 +compare_posix_output "var expr" 'a=3; b=4; echo $((a*a+b*b))'
 +compare_posix_output "var unset" 'unset z; echo $((z))'
 +compare_posix_output "var ref" 'X=10; echo $((X + 5))'
++
 +section "10. NUMBER BASES"
 +compare_posix_output "octal" 'echo $((010))'
 +compare_posix_output "hex" 'echo $((0x10))'
 +compare_posix_output "hex lowercase" 'echo $((0xa))'
++
 +section "11. INCREMENT/DECREMENT"
 +compare_posix_output "preinc" 'x=5; echo $((++x))'
 +compare_posix_output "predec" 'x=5; echo $((--x))'
 +compare_posix_output "postinc" 'x=5; echo $((x++))'
 +compare_posix_output "postdec" 'x=5; echo $((x--))'
++
 +section "12. EDGE CASES"
 +compare_posix_output "negative numbers" "echo \$((-5 * -3))"
 +compare_posix_output "large numbers" "echo \$((999999 + 1))"
 +compare_posix_output "modulo negative" "echo \$((-17 % 5))"
 +compare_posix_output "comparison chain" "echo \$((5 > 3 && 10 > 8))"
 +compare_posix_output "unary minus" "X=5; echo \$((-X))"
 +compare_posix_output "unary plus" "X=5; echo \$((+X))"
 +compare_posix_output "zero" 'echo $((0))'
 +compare_posix_output "nested arith" 'echo $(($((1 + 2)) + 3))'
 +compare_posix_exit_code "division by zero" "echo \$((5 / 0)) 2>/dev/null"
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "ARITHMETIC GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_builtins.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Builtin Gap Tests
 +# =====================================
 +# Tests for POSIX shell builtins
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-builtins]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    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=$?
 +    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)
 +    if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$fortsh_out"; fi
 +}
++
 +# ============================================================================
 +# CD BUILTIN
 +# ============================================================================
++
 +section "1. CD BUILTIN"
 +compare_posix_output "cd tmp" 'cd /tmp; pwd'
 +compare_posix_output "cd home" 'cd ~; pwd | grep -c /'
 +compare_posix_output "cd dash" 'cd /tmp; cd /; cd -'
 +compare_posix_output "cd dotdot" 'cd /tmp; cd ..; pwd'
++
 +# ============================================================================
 +# PWD BUILTIN
 +# ============================================================================
++
 +section "2. PWD BUILTIN"
 +compare_posix_output "pwd basic" 'pwd | grep -c /'
 +compare_posix_output "pwd P" 'pwd -P | grep -c /'
 +compare_posix_output "pwd L" 'pwd -L | grep -c /'
++
 +# ============================================================================
 +# ECHO BUILTIN
 +# ============================================================================
++
 +section "3. ECHO BUILTIN"
 +compare_posix_output "echo basic" 'echo hello'
 +compare_posix_output "echo multi" 'echo hello world'
 +compare_posix_output "echo empty" 'echo ""'
 +compare_posix_output "echo n" 'echo -n hello; echo world'
 +compare_posix_output "echo special" 'echo "a\tb"'
++
 +# ============================================================================
 +# PRINTF BUILTIN
 +# ============================================================================
++
 +section "4. PRINTF BUILTIN"
 +compare_posix_output "printf s" 'printf "%s\n" hello'
 +compare_posix_output "printf d" 'printf "%d\n" 42'
 +compare_posix_output "printf x" 'printf "%x\n" 255'
 +compare_posix_output "printf o" 'printf "%o\n" 8'
 +compare_posix_output "printf width" 'printf "%5d\n" 42'
 +compare_posix_output "printf left" 'printf "%-5d|\n" 42'
 +compare_posix_output "printf zero" 'printf "%05d\n" 42'
++
 +# ============================================================================
 +# TEST BUILTIN
 +# ============================================================================
++
 +section "5. TEST NUMERIC OPERATORS"
 +compare_posix_output "test eq" '[ 5 -eq 5 ]; echo $?'
 +compare_posix_output "test ne" '[ 5 -ne 3 ]; echo $?'
 +compare_posix_output "test lt" '[ 3 -lt 5 ]; echo $?'
 +compare_posix_output "test gt" '[ 5 -gt 3 ]; echo $?'
 +compare_posix_output "test le" '[ 5 -le 5 ]; echo $?'
 +compare_posix_output "test ge" '[ 5 -ge 5 ]; echo $?'
++
 +section "6. TEST STRING OPERATORS"
 +compare_posix_output "test z empty" '[ -z "" ]; echo $?'
 +compare_posix_output "test z nonempty" '[ -z "x" ]; echo $?'
 +compare_posix_output "test n empty" '[ -n "" ]; echo $?'
 +compare_posix_output "test n nonempty" '[ -n "x" ]; echo $?'
 +compare_posix_output "test str eq" '[ "a" = "a" ]; echo $?'
 +compare_posix_output "test str ne" '[ "a" != "b" ]; echo $?'
++
 +section "7. TEST FILE OPERATORS"
 +compare_posix_output "test f" '[ -f /etc/passwd ]; echo $?'
 +compare_posix_output "test d" '[ -d /tmp ]; echo $?'
 +compare_posix_output "test e" '[ -e /tmp ]; echo $?'
 +compare_posix_output "test r" '[ -r /etc/passwd ]; echo $?'
 +compare_posix_output "test x" '[ -x /bin/sh ]; echo $?'
 +compare_posix_output "test s" 'echo x > /tmp/ts$$; [ -s /tmp/ts$$ ]; echo $?; rm /tmp/ts$$'
++
 +section "8. TEST COMPOUND"
 +compare_posix_output "test and" '[ -d /tmp -a -f /etc/passwd ]; echo $?'
 +compare_posix_output "test or" '[ -d /nonexistent -o -f /etc/passwd ]; echo $?'
 +compare_posix_output "test not" '[ ! -d /nonexistent ]; echo $?'
 +compare_posix_output "test paren" '[ \( -d /tmp \) ]; echo $?'
++
 +# ============================================================================
 +# TYPE AND COMMAND BUILTINS
 +# ============================================================================
++
 +section "9. TYPE BUILTIN"
 +compare_posix_output "type builtin" "type echo | grep -ci 'builtin\\|built-in\\|shell builtin'"
 +compare_posix_output "type function" "f() { :; }; type f | grep -c function"
 +compare_posix_output "type external" "type cat | grep -c '/'"
 +compare_posix_exit_code "type nonexistent" "type nonexistent_$$ 2>/dev/null"
++
 +section "10. COMMAND BUILTIN"
 +compare_posix_output "command v" 'command -v echo | grep -c echo'
 +compare_posix_output "command V" 'command -V echo 2>/dev/null | grep -c echo'
 +compare_posix_output "command p" 'command -p echo test'
++
 +# ============================================================================
 +# SET BUILTIN
 +# ============================================================================
++
 +section "11. SET BUILTIN"
 +compare_posix_output "set -- clears positionals" "set -- a b; set --; echo \$#"
 +compare_posix_error "set -- with empty" "set -- ''; echo \$# |\$1|"
 +compare_posix_output "set -- with spaces" "set -- 'a b' 'c d'; echo \$1"
 +compare_posix_output "set without args shows vars" "X=1; set | grep -c '^X='"
 +compare_posix_output "set -o lists options" "set -o 2>&1 | wc -l"
 +compare_posix_output "set args" 'set -- a b c; echo $1 $2 $3'
 +compare_posix_output "set count" 'set -- a b c d e; echo $#'
 +compare_posix_output "set all" 'set -- x y z; echo "$@"'
 +compare_posix_output "set star" 'set -- x y z; echo "$*"'
++
 +# ============================================================================
 +# SHIFT BUILTIN
 +# ============================================================================
++
 +section "12. SHIFT BUILTIN"
 +compare_posix_output "shift basic" 'set -- a b c; shift; echo $1'
 +compare_posix_output "shift count" 'set -- a b c; shift; echo $#'
 +compare_posix_output "shift 2" 'set -- a b c d; shift 2; echo $1'
 +compare_posix_output "shift with count" "set -- a b c d e; shift 3; echo \$1"
 +compare_posix_exit_code "shift too many" "set -- a b; shift 5 2>/dev/null"
 +compare_posix_output "shift zero" "set -- a b c; shift 0; echo \$#"
 +compare_posix_output "shift all" "set -- a b c; shift 3; echo \$#"
 +compare_posix_exit_code "shift with no args" "set --; shift 2>/dev/null"
++
 +# ============================================================================
 +# EVAL BUILTIN
 +# ============================================================================
++
 +section "13. EVAL BUILTIN"
 +compare_posix_output "eval with semicolons" "eval 'echo a; echo b' | wc -l"
 +compare_posix_output "eval with pipes" "eval 'echo test | cat'"
 +compare_posix_output "eval with redirects" "eval 'echo test > /tmp/posix_gaps_eval_$$'; cat /tmp/posix_gaps_eval_$$; rm -f /tmp/posix_gaps_eval_$$"
 +compare_posix_output "eval double expansion" "VAR='echo \$HOME'; eval \$VAR | grep -c /"
 +compare_posix_output "eval empty string" "eval ''; echo ok"
 +compare_posix_output "nested eval" "eval eval echo nested"
++
 +# ============================================================================
 +# READONLY AND UNSET
 +# ============================================================================
++
 +section "14. READONLY"
 +compare_posix_exit_code "readonly then unset fails" "readonly X=1; unset X 2>/dev/null"
 +compare_posix_exit_code "export readonly" "readonly X=1; export X; sh -c 'echo \$X' | grep -c 1"
 +compare_posix_output "readonly in subshell" "(readonly Y=2; echo \$Y); readonly | grep -c Y || echo 0"
 +compare_posix_output "readonly basic" 'readonly Y=5; echo $Y'
 +compare_posix_output "readonly list" 'readonly | grep -c .'
++
 +section "15. UNSET"
 +compare_posix_output "unset var" 'x=5; unset x; echo ${x:-unset}'
 +compare_posix_output "unset func" 'f() { echo f; }; unset -f f; f 2>/dev/null || echo unset'
 +compare_posix_output "unset v flag" 'x=5; unset -v x; echo ${x:-unset}'
++
 +# ============================================================================
 +# EXPORT
 +# ============================================================================
++
 +section "16. EXPORT"
 +compare_posix_output "export basic" 'export X=5; sh -c "echo \$X"'
 +compare_posix_output "export list" 'export | grep -c ='
++
 +# ============================================================================
 +# RETURN AND DOT
 +# ============================================================================
++
 +section "17. RETURN BUILTIN"
 +compare_posix_output "return without function" "return 2>/dev/null || echo ok"
 +compare_posix_output "return value preserved" "f() { return 42; }; f; echo \$?"
 +compare_posix_output "return in sourced script" "echo 'return 7' > /tmp/posix_gaps_source_$$; . /tmp/posix_gaps_source_$$ 2>/dev/null || echo \$?; rm -f /tmp/posix_gaps_source_$$"
++
 +section "18. DOT BUILTIN"
 +compare_posix_output "source with PATH search" "echo 'echo sourced' > /tmp/posix_gaps_dot_$$; PATH=/tmp:\$PATH; . posix_gaps_dot_$$ 2>/dev/null || echo 'not found'; rm -f /tmp/posix_gaps_dot_$$"
 +compare_posix_exit_code "source nonexistent" ". /tmp/posix_gaps_nonexistent_$$ 2>/dev/null"
 +compare_posix_output "source preserves variables" "echo 'A=from_source' > /tmp/posix_gaps_dot2_$$; . /tmp/posix_gaps_dot2_$$; echo \$A; rm -f /tmp/posix_gaps_dot2_$$"
++
 +# ============================================================================
 +# GETOPTS
 +# ============================================================================
++
 +section "19. GETOPTS"
 +compare_posix_output "getopts basic" "set -- -a test; getopts 'a:' opt; echo \$opt"
 +compare_posix_output "getopts OPTARG" "set -- -a value; getopts 'a:' opt; echo \$OPTARG"
 +compare_posix_output "getopts OPTIND" "set -- -a -b; getopts 'ab' opt; echo \$OPTIND"
 +compare_posix_output "getopts invalid option" "set -- -z; getopts 'ab' opt 2>/dev/null; echo \$opt | grep -c '?'"
++
 +# ============================================================================
 +# UMASK
 +# ============================================================================
++
 +section "20. UMASK"
 +compare_posix_output "umask get" "umask | grep -c '^[0-9]*\$'"
 +compare_posix_output "umask set and get" "old=\$(umask); umask 022; umask; umask \$old | head -1"
++
 +# ============================================================================
 +# HASH
 +# ============================================================================
++
 +section "21. HASH"
 +compare_posix_exit_code "hash command" "hash echo 2>/dev/null"
 +compare_posix_exit_code "hash -r clears" "hash -r"
 +compare_posix_exit_code "hash nonexistent" "hash nonexistent_cmd_$$ 2>/dev/null"
++
 +# ============================================================================
 +# TIMES
 +# ============================================================================
++
 +section "22. TIMES"
 +compare_posix_output "times output format" "times | wc -l"
 +compare_posix_exit_code "times exit status" "times >/dev/null"
++
 +# ============================================================================
 +# TRAP
 +# ============================================================================
++
 +section "23. TRAP"
 +compare_posix_output "trap with signal number" "trap 'echo sig' 15; trap | grep -c 15"
 +compare_posix_output "trap with multiple signals" "trap 'echo multi' INT TERM; trap | grep -c 'echo multi'"
 +compare_posix_output "trap ignore signal" "trap '' INT; trap | grep INT | grep -c ''"
++
 +# ============================================================================
 +# EXIT
 +# ============================================================================
++
 +section "24. EXIT"
 +compare_posix_exit_code "exit with status" "sh -c 'exit 42'"
 +compare_posix_exit_code "exit in subshell" "(exit 7); echo \$?"
++
 +# ============================================================================
 +# VARIABLE OPERATIONS
 +# ============================================================================
++
 +section "25. VARIABLE ASSIGNMENT"
 +compare_posix_output "var simple" 'x=5; echo $x'
 +compare_posix_output "var empty" 'x=; echo "[$x]"'
 +compare_posix_output "var quoted" 'x="a b"; echo "$x"'
 +compare_posix_output "var concat" 'x=hel; y=lo; echo $x$y'
 +compare_posix_output "var braces" 'x=val; echo ${x}'
++
 +section "26. FUNCTION SCOPE"
 +compare_posix_output "func global" 'x=global; f() { x=func; }; f; echo $x'
 +compare_posix_output "func params" 'f() { echo $# $1 $2; }; f a b c'
 +compare_posix_output "func shift" 'f() { shift; echo $1; }; f a b c'
++
 +# ============================================================================
 +# MISCELLANEOUS
 +# ============================================================================
++
 +section "27. MISCELLANEOUS EDGE CASES"
 +compare_posix_output "empty command in list" ": ; echo ok"
 +compare_posix_output "whitespace only" "   ; echo ok"
 +compare_posix_output "multiple empty commands" ": ; : ; echo ok"
 +compare_posix_output "empty string as command" "'' 2>/dev/null || echo ok"
++
 +section "28. PIPELINES"
 +compare_posix_output "five stage pipeline" "echo test | cat | cat | cat | cat"
 +compare_posix_exit_code "pipeline with negation" "! false | false"
 +compare_posix_output "pipeline with subshell" "(echo a; echo b) | wc -l"
 +compare_posix_output "pipeline with brace group" "{ echo x; echo y; } | wc -l"
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "BUILTINS GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_charclass.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Character Class Gap Tests
 +# =====================================
 +# Tests for POSIX character classes in bracket expressions
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-charclass]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$fortsh_out"; fi
 +}
++
 +# ============================================================================
 +# CHARACTER CLASS TESTS
 +# ============================================================================
++
 +section "1. CHARACTER CLASS ALNUM"
 +compare_posix_output "alnum a" 'case a in [[:alnum:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "alnum Z" 'case Z in [[:alnum:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "alnum 5" 'case 5 in [[:alnum:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "alnum excl" 'case "!" in [[:alnum:]]) echo yes;; *) echo no;; esac'
++
 +section "2. CHARACTER CLASS ALPHA"
 +compare_posix_output "alpha a" 'case a in [[:alpha:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "alpha Z" 'case Z in [[:alpha:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "alpha 5" 'case 5 in [[:alpha:]]) echo yes;; *) echo no;; esac'
++
 +section "3. CHARACTER CLASS DIGIT"
 +compare_posix_output "digit 0" 'case 0 in [[:digit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "digit 9" 'case 9 in [[:digit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "digit a" 'case a in [[:digit:]]) echo yes;; *) echo no;; esac'
++
 +section "4. CHARACTER CLASS LOWER"
 +compare_posix_output "lower a" 'case a in [[:lower:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "lower z" 'case z in [[:lower:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "lower A" 'case A in [[:lower:]]) echo yes;; *) echo no;; esac'
++
 +section "5. CHARACTER CLASS UPPER"
 +compare_posix_output "upper A" 'case A in [[:upper:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "upper Z" 'case Z in [[:upper:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "upper a" 'case a in [[:upper:]]) echo yes;; *) echo no;; esac'
++
 +section "6. CHARACTER CLASS SPACE"
 +compare_posix_output "space sp" 'case " " in [[:space:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "space tab" 'case "	" in [[:space:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "space a" 'case a in [[:space:]]) echo yes;; *) echo no;; esac'
++
 +section "7. CHARACTER CLASS BLANK"
 +compare_posix_output "blank sp" 'case " " in [[:blank:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "blank tab" 'case "	" in [[:blank:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "blank a" 'case a in [[:blank:]]) echo yes;; *) echo no;; esac'
++
 +section "8. CHARACTER CLASS PUNCT"
 +compare_posix_output "punct dot" 'case "." in [[:punct:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "punct excl" 'case "!" in [[:punct:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "punct a" 'case a in [[:punct:]]) echo yes;; *) echo no;; esac'
++
 +section "9. CHARACTER CLASS XDIGIT"
 +compare_posix_output "xdigit 0" 'case 0 in [[:xdigit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "xdigit a" 'case a in [[:xdigit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "xdigit F" 'case F in [[:xdigit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "xdigit g" 'case g in [[:xdigit:]]) echo yes;; *) echo no;; esac'
++
 +section "10. CHARACTER CLASS PRINT GRAPH"
 +compare_posix_output "print a" 'case a in [[:print:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "print sp" 'case " " in [[:print:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "graph a" 'case a in [[:graph:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "graph sp" 'case " " in [[:graph:]]) echo yes;; *) echo no;; esac'
++
 +section "11. CHARACTER CLASS CNTRL"
 +compare_posix_output "cntrl a" 'case a in [[:cntrl:]]) echo yes;; *) echo no;; esac'
++
 +section "12. COMBINED CHARACTER CLASSES"
 +compare_posix_output "combo alpha digit a" 'case a in [[:alpha:][:digit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "combo alpha digit 5" 'case 5 in [[:alpha:][:digit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "combo alpha digit excl" 'case "!" in [[:alpha:][:digit:]]) echo yes;; *) echo no;; esac'
++
 +section "13. NEGATED CHARACTER CLASSES"
 +compare_posix_output "not digit a" 'case a in [^[:digit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "not digit 5" 'case 5 in [^[:digit:]]) echo yes;; *) echo no;; esac'
 +compare_posix_output "not alpha bang" 'case a in [![:alpha:]]) echo yes;; *) echo no;; esac'
++
 +section "14. RANGE EXPRESSIONS"
 +compare_posix_output "range a-z m" 'case m in [a-z]) echo yes;; *) echo no;; esac'
 +compare_posix_output "range A-Z M" 'case M in [A-Z]) echo yes;; *) echo no;; esac'
 +compare_posix_output "range 0-9 5" 'case 5 in [0-9]) echo yes;; *) echo no;; esac'
 +compare_posix_output "range combo" 'case M in [a-zA-Z]) echo yes;; *) echo no;; esac'
++
 +section "15. BRACKET EDGE CASES"
 +compare_posix_output "literal hyphen start" 'case "-" in [-abc]) echo yes;; *) echo no;; esac'
 +compare_posix_output "literal hyphen end" 'case "-" in [abc-]) echo yes;; *) echo no;; esac'
 +compare_posix_output "literal caret" 'case "^" in [a^b]) echo yes;; *) echo no;; esac'
 +compare_posix_output "literal rbracket" 'case "]" in []abc]) echo yes;; *) echo no;; esac'
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "CHARACTER CLASS GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_control.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Control Flow Gap Tests
 +# =====================================
 +# Tests for POSIX control flow constructs
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-control]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$fortsh_out"; fi
 +}
++
 +# ============================================================================
 +# IF STATEMENTS
 +# ============================================================================
++
 +section "1. IF BASIC"
 +compare_posix_output "if true" 'if true; then echo yes; fi'
 +compare_posix_output "if false" 'if false; then echo yes; fi; echo done'
 +compare_posix_output "if else" 'if false; then echo no; else echo yes; fi'
 +compare_posix_output "if elif" 'if false; then echo 1; elif true; then echo 2; fi'
 +compare_posix_output "if elif else" 'if false; then echo 1; elif false; then echo 2; else echo 3; fi'
 +compare_posix_output "if nested" 'if true; then if true; then echo deep; fi; fi'
++
 +section "2. IF CONDITIONS"
 +compare_posix_output "if and" 'if true && true; then echo yes; fi'
 +compare_posix_output "if or" 'if false || true; then echo yes; fi'
 +compare_posix_output "if not" 'if ! false; then echo yes; fi'
++
 +# ============================================================================
 +# FOR LOOPS
 +# ============================================================================
++
 +section "3. FOR BASIC"
 +compare_posix_output "for simple" 'for i in a b c; do echo $i; done'
 +compare_posix_output "for numbers" 'for i in 1 2 3; do echo $i; done | wc -l'
 +compare_posix_output "for empty" 'for i in; do echo $i; done; echo done'
 +compare_posix_output "for single" "for i in one; do echo \$i; done"
++
 +section "4. FOR EDGE CASES"
 +compare_posix_output "for with break" 'for i in 1 2 3; do echo $i; break; done'
 +compare_posix_output "for with continue" 'for i in 1 2 3; do if [ $i = 2 ]; then continue; fi; echo $i; done'
 +# 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_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)
 +if [ "$_glob_posix_n" = "$_glob_fortsh_n" ]; then pass "for glob expansion"
 +else fail "for glob expansion" "$_glob_posix_n" "$_glob_fortsh_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"
++
 +# ============================================================================
 +# WHILE LOOPS
 +# ============================================================================
++
 +section "5. WHILE BASIC"
 +compare_posix_output "while basic" 'i=0; while [ $i -lt 3 ]; do echo $i; i=$((i+1)); done'
 +compare_posix_output "while false" 'while false; do echo no; done; echo done'
 +compare_posix_output "while break" 'while true; do echo once; break; done'
 +compare_posix_output "while count" 'n=3; while [ $n -gt 0 ]; do n=$((n-1)); done; echo $n'
++
 +section "6. WHILE EDGE CASES"
 +compare_posix_output "while true with break" "i=0; while true; do i=\$((i+1)); test \$i -eq 3 && break; done; echo \$i"
 +compare_posix_output "while with exit status" "i=5; while [ \$i -gt 0 ]; do i=\$((i-1)); done; echo \$?"
++
 +# ============================================================================
 +# UNTIL LOOPS
 +# ============================================================================
++
 +section "7. UNTIL BASIC"
 +compare_posix_output "until basic" 'i=0; until [ $i -ge 3 ]; do echo $i; i=$((i+1)); done'
 +compare_posix_output "until true" 'until true; do echo no; done; echo done'
 +compare_posix_output "until count" 'n=0; until [ $n -eq 3 ]; do n=$((n+1)); done; echo $n'
++
 +section "8. UNTIL EDGE CASES"
 +compare_posix_output "until false with break" "i=0; until false; do i=\$((i+1)); test \$i -eq 3 && break; done; echo \$i"
 +compare_posix_output "until complex condition" "i=0; until [ \$i -gt 3 ] && [ \$i -lt 10 ]; do i=\$((i+1)); done; echo \$i"
++
 +# ============================================================================
 +# CASE STATEMENTS
 +# ============================================================================
++
 +section "9. CASE BASIC"
 +compare_posix_output "case single" 'case x in x) echo yes;; esac'
 +compare_posix_output "case default" 'case y in x) echo no;; *) echo yes;; esac'
 +compare_posix_output "case multi" 'case b in a|b|c) echo abc;; esac'
 +compare_posix_output "case glob" 'case abc in a*) echo yes;; esac'
 +compare_posix_output "case nested" 'case x in x) case y in y) echo deep;; esac;; esac'
++
 +section "10. CASE PATTERNS"
 +compare_posix_output "case glob star" 'case abc in a*) echo star;; esac'
 +compare_posix_output "case glob question" 'case abc in a?c) echo match;; esac'
 +compare_posix_output "case glob bracket" 'case abc in [a-z]*) echo match;; esac'
 +compare_posix_output "case no match" 'case x in y) echo no;; esac; echo done'
 +compare_posix_output "case empty" 'case "" in "") echo empty;; esac'
 +compare_posix_output "case with var" 'x=test; case $x in test) echo yes;; esac'
 +compare_posix_output "case quoted" 'case "a b" in "a b") echo space;; esac'
++
 +section "11. CASE EDGE CASES"
 +compare_posix_output "case empty pattern" "x=''; case \$x in '') echo empty;; esac"
 +compare_posix_output "case with quotes" "x='a b'; case \$x in 'a b') echo match;; esac"
 +compare_posix_output "case glob vs literal" "x='*'; case \$x in '*') echo literal;; esac"
 +compare_posix_output "case bracket range" "x=b; case \$x in [a-c]) echo range;; esac"
 +compare_posix_output "case multiple patterns order" "x=a; case \$x in a|b) echo first;; a) echo second;; esac"
 +compare_posix_output "case with variable pattern" "P='a*'; x=abc; case \$x in \$P) echo var_pattern;; esac"
++
 +# ============================================================================
 +# BREAK AND CONTINUE
 +# ============================================================================
++
 +section "12. BREAK"
 +compare_posix_output "break simple" 'for i in 1 2 3; do echo $i; break; done'
 +compare_posix_output "break nested" 'for i in 1 2; do for j in a b; do echo $i$j; break; done; done'
 +compare_posix_output "break 2" 'for i in 1 2; do for j in a b; do echo $i$j; break 2; done; done'
++
 +section "13. CONTINUE"
 +compare_posix_output "continue simple" 'for i in 1 2 3; do if [ $i = 2 ]; then continue; fi; echo $i; done'
 +compare_posix_output "continue 2" 'for i in 1 2; do for j in a b; do if [ $j = a ]; then continue 2; fi; echo $i$j; done; done'
++
 +section "14. BREAK/CONTINUE EDGE CASES"
 +compare_posix_output "break with level 0" "for i in 1 2; do break 0 2>/dev/null || break; echo \$i; done || echo ok"
 +compare_posix_output "break level too high" "for i in 1 2; do break 10 2>/dev/null || break; echo \$i; done || echo done"
 +compare_posix_output "continue with level" "for i in 1 2; do for j in a b; do continue 2 2>/dev/null || continue; echo \$i\$j; done; done || echo ok"
 +compare_posix_output "break outside loop" "break 2>/dev/null || echo ok"
 +compare_posix_output "continue outside loop" "continue 2>/dev/null || echo ok"
++
 +# ============================================================================
 +# FUNCTIONS
 +# ============================================================================
++
 +section "15. FUNCTION DEFINITION"
 +compare_posix_output "func basic" 'f() { echo hello; }; f'
 +compare_posix_output "func args" 'f() { echo $1 $2; }; f a b'
 +compare_posix_output "func return" 'f() { return 5; }; f; echo $?'
 +compare_posix_output "func positional" 'f() { echo $# $@; }; f a b c'
++
 +section "16. RETURN AND EXIT"
 +compare_posix_output "return basic" 'f() { return; }; f; echo $?'
 +compare_posix_output "return code" 'f() { return 5; }; f; echo $?'
 +compare_posix_output "exit subshell" '(exit 5); echo $?'
 +compare_posix_output "exit code" '(exit 42); echo $?'
++
 +# ============================================================================
 +# SUBSHELL AND BRACE GROUPS
 +# ============================================================================
++
 +section "17. SUBSHELL"
 +compare_posix_output "subshell basic" '(echo hello)'
 +compare_posix_output "subshell var" 'x=1; (x=2); echo $x'
 +compare_posix_output "subshell exit" '(exit 5); echo $?'
++
 +section "18. SUBSHELL VARIABLE ISOLATION"
 +compare_posix_output "subshell doesnt modify parent" "(X=inner); echo \${X:-unset}"
 +compare_posix_output "subshell inherits variables" "X=outer; (echo \$X)"
 +compare_posix_output "nested subshells" "X=1; (X=2; (X=3; echo \$X); echo \$X); echo \$X"
 +compare_posix_output "subshell with exports" "export X=exp; (X=inner; echo \$X); echo \$X"
++
 +section "19. BRACE GROUPS"
 +compare_posix_output "brace basic" '{ echo hello; }'
 +compare_posix_output "brace var" 'x=1; { x=2; }; echo $x'
 +compare_posix_output "brace redir" '{ echo a; echo b; } > /tmp/b$$; wc -l < /tmp/b$$; rm /tmp/b$$'
 +compare_posix_output "brace group modifies parent" "X=1; { X=2; }; echo \$X"
 +compare_posix_output "brace group with redirects" "{ echo a; echo b; } | wc -l"
 +compare_posix_output "nested brace groups" "X=1; { { X=2; }; echo \$X; }; echo \$X"
++
 +# ============================================================================
 +# LOGICAL OPERATORS
 +# ============================================================================
++
 +section "20. LOGICAL OPERATORS"
 +compare_posix_output "and both true" 'true && echo yes'
 +compare_posix_output "and first false" 'false && echo no; echo done'
 +compare_posix_output "or first true" 'true || echo no; echo done'
 +compare_posix_output "or first false" 'false || echo yes'
 +compare_posix_output "not true" '! true; echo $?'
 +compare_posix_output "not false" '! false; echo $?'
++
 +# ============================================================================
 +# NESTED LOOPS
 +# ============================================================================
++
 +section "21. NESTED LOOPS"
 +compare_posix_output "nested for" 'for i in 1 2; do for j in a b; do echo $i$j; done; done | wc -l'
 +compare_posix_output "loop with pipe" 'for i in 1 2 3; do echo $i; done | head -2'
++
 +# Summary
 +printf "\n==========================================\n"
 +if [ -n "$_glob_debug" ]; then printf "%s\n" "$_glob_debug"; fi
 +printf "CONTROL FLOW GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_heredoc.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Here-Document Gap Tests
 +# =====================================
 +# Tests for POSIX here-document functionality
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-heredoc]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    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=$?
 +    if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
 +}
++
 +# ============================================================================
 +# HEREDOC TESTS
 +# ============================================================================
++
 +section "1. BASIC HEREDOC"
 +compare_posix_output "simple" 'cat <<EOF
 +hello
 +EOF'
 +compare_posix_output "multiline" 'cat <<EOF
 +line1
 +line2
 +EOF'
 +compare_posix_output "empty" 'cat <<EOF
 +EOF'
++
 +section "2. VARIABLE EXPANSION"
 +compare_posix_output "var expansion" 'x=value; cat <<EOF
 +$x
 +EOF'
 +compare_posix_output "var with text" 'X=world; cat <<EOF
 +hello $X
 +EOF'
++
 +section "3. COMMAND SUBSTITUTION"
 +compare_posix_output "cmd sub" 'cat <<EOF
 +$(echo hello)
 +EOF'
++
 +section "4. ARITHMETIC EXPANSION"
 +compare_posix_output "arith" 'cat <<EOF
 +$((1+2))
 +EOF'
++
 +section "5. QUOTED DELIMITER"
 +compare_posix_output "single quoted" "cat <<'EOF'
 +\$x \$(cmd)
 +EOF"
 +compare_posix_output "double quoted" 'cat <<"EOF"
 +$x $(cmd)
 +EOF'
 +compare_posix_output "quoted no expand" "cat <<'EOF'
 +\$notvar
 +EOF"
++
 +section "6. TAB STRIPPING (<<-)"
 +compare_posix_output "dash strips tabs" "cat <<-EOF
 +	line1
 +		line2
 +	line3
 +EOF"
 +compare_posix_output "dash mixed" "cat <<-EOF
 +	tab_line
 +    space_line
 +EOF"
 +compare_posix_output "dash with vars" "VAR=test; cat <<-EOF
 +	value=\$VAR
 +	end
 +EOF"
 +compare_posix_output "dash quoted" "cat <<-'EOF'
 +	\$VAR
 +	literal
 +EOF"
 +compare_posix_output "dash simple" 'cat <<-EOF
 +	tabbed
 +	EOF'
++
 +section "7. MULTIPLE HEREDOCS"
 +compare_posix_output "double heredoc" 'cat <<EOF1; cat <<EOF2
 +first
 +EOF1
 +second
 +EOF2'
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "HEREDOC GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_quoting.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Quoting Gap Tests
 +# =====================================
 +# Tests for POSIX quoting mechanisms
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-quoting]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
 +    else fail "$test_name" "$posix_out" "$fortsh_out"; fi
 +}
++
 +# ============================================================================
 +# QUOTING TESTS
 +# ============================================================================
++
 +section "1. SINGLE QUOTING"
 +compare_posix_output "simple" "echo 'hello'"
 +compare_posix_output "with space" "echo 'hello world'"
 +compare_posix_output "dollar literal" "echo '\$x'"
 +compare_posix_output "backtick literal" "echo '\`cmd\`'"
 +compare_posix_output "backslash literal" "echo '\\'"
++
 +section "2. DOUBLE QUOTING"
 +compare_posix_output "simple" 'echo "hello"'
 +compare_posix_output "with space" 'echo "hello world"'
 +compare_posix_output "var expand" 'x=val; echo "$x"'
 +compare_posix_output "escaped dollar" 'echo "\$x"'
 +compare_posix_output "escaped quote" 'echo "hello\"world"'
++
 +section "3. BACKSLASH ESCAPING"
 +compare_posix_output "escape space" 'echo hello\ world'
 +compare_posix_output "escape dollar" 'echo \$x'
 +compare_posix_output "escape newline" 'echo hello\
 +world'
 +compare_posix_output "escape backslash" 'echo \\\\'
++
 +section "4. MIXED QUOTING"
 +compare_posix_output "single in double" 'echo "'"'"'"'
 +compare_posix_output "double in single" "echo '\"'"
 +compare_posix_output "concat quotes" "echo 'a'b'c'"
 +compare_posix_output "quote switching" 'echo "a'"'"'b"'
++
 +section "5. EMPTY QUOTES"
 +compare_posix_output "empty single" "echo ''"
 +compare_posix_output "empty double" 'echo ""'
 +compare_posix_output "empty in string" 'echo a""b'
 +compare_posix_output "empty as arg" 'set -- ""; echo $#'
++
 +section "6. COMPLEX ESCAPING"
 +compare_posix_output "backslash in dquotes" 'echo "test\\nword"'
 +compare_posix_output "dollar in dquotes" 'echo "cost: \$5"'
 +compare_posix_output "backtick in dquotes" 'echo "date: \`date +%Y\`" | grep -c date'
 +compare_posix_output "mixed quoting" "echo 'single'\"double\"'single'"
 +compare_posix_output "empty concat" "echo ''test''"
 +compare_posix_output "quote removal" 'VAR="\"test\""; echo $VAR'
 +compare_posix_output "backslash newline" "echo 'line1\
 +line2' | wc -l"
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "QUOTING GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_redirect.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Redirection Gap Tests
 +# =====================================
 +# Tests for POSIX redirection operators
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-redirect]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    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=$?
 +    if [ "$posix_code" = "$fortsh_code" ]; then pass "$test_name"
 +    else fail "$test_name" "exit $posix_code" "exit $fortsh_code"; fi
 +}
++
 +# ============================================================================
 +# BASIC REDIRECTIONS
 +# ============================================================================
++
 +section "1. OUTPUT REDIRECTION"
 +compare_posix_output "redir out" 'echo test > /tmp/r$$; cat /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir in" 'echo test > /tmp/r$$; cat < /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir append" 'echo a > /tmp/r$$; echo b >> /tmp/r$$; cat /tmp/r$$; rm /tmp/r$$'
 +compare_posix_output "redir stderr" 'ls /nonexistent$$ 2>/dev/null; echo done'
++
 +section "2. READ/WRITE REDIRECTION"
 +compare_posix_exit_code "redirect <> creates file" "echo test <> /tmp/posix_gaps_rw_$$; test -f /tmp/posix_gaps_rw_$$; rm -f /tmp/posix_gaps_rw_$$"
 +compare_posix_exit_code "redirect <> opens existing" "echo data > /tmp/posix_gaps_rw2_$$; cat <> /tmp/posix_gaps_rw2_$$ 2>/dev/null; rm -f /tmp/posix_gaps_rw2_$$"
++
 +# ============================================================================
 +# ADVANCED REDIRECTIONS
 +# ============================================================================
++
 +section "3. FD REDIRECTION"
 +compare_posix_output "redirect order matters" "echo test 2>&1 >/dev/null | wc -l"
 +compare_posix_output "redirect to same fd" "echo test >&1 2>&1"
 +compare_posix_output "redirect append" "echo a > /tmp/posix_gaps_redir_$$; echo b >> /tmp/posix_gaps_redir_$$; wc -l < /tmp/posix_gaps_redir_$$; rm -f /tmp/posix_gaps_redir_$$"
++
 +section "4. HERE DOCUMENTS IN REDIRECT"
 +compare_posix_output "redirect here-string alternative" "cat <<EOF
 +test
 +EOF"
 +compare_posix_output "redirect duplicate stdin" "cat <&0 <<EOF
 +input
 +EOF"
++
 +section "5. LOOP REDIRECTIONS"
 +compare_posix_output "redirect in loop" 'for i in 1 2 3; do echo $i; done > /tmp/redir_test_$$; cat /tmp/redir_test_$$; rm /tmp/redir_test_$$'
 +compare_posix_output "append multiple" 'echo a >> /tmp/app_test_$$; echo b >> /tmp/app_test_$$; cat /tmp/app_test_$$; rm /tmp/app_test_$$'
 +compare_posix_output "stderr to file" 'ls /nonexistent 2>/tmp/err_test_$$ || cat /tmp/err_test_$$ | wc -l; rm -f /tmp/err_test_$$'
++
 +# ============================================================================
 +# IFS FIELD SPLITTING
 +# ============================================================================
++
 +section "6. IFS FIELD SPLITTING"
 +compare_posix_output "IFS mixed ws and non-ws" "IFS=': \t'; VAR='a:b c:d'; set -- \$VAR; echo \$# \$1 \$2 \$3 \$4"
 +compare_posix_output "IFS multiple delimiters" "IFS=',:'; VAR='a,b:c,d'; set -- \$VAR; echo \$#"
 +compare_posix_output "IFS trailing delimiters" "IFS=:; VAR='a:b:c:'; set -- \$VAR; echo \$#"
 +compare_posix_output "IFS leading and trailing" "IFS=:; VAR=':a:b:'; set -- \$VAR; echo \$# \$1 \$2"
 +compare_posix_output "IFS consecutive delimiters" "IFS=:; VAR='a::b'; set -- \$VAR; echo \$# \$1 \$2 \$3"
 +compare_posix_output "IFS whitespace collapsing" "IFS=' '; VAR='a  b   c'; set -- \$VAR; echo \$#"
++
 +# ============================================================================
 +# COMMENTS
 +# ============================================================================
++
 +section "7. COMMENTS"
 +compare_posix_output "comment inline" 'echo yes # comment'
 +compare_posix_output "comment in dquote" 'echo "not # comment"'
 +compare_posix_output "comment in squote" "echo 'not # comment'"
++
 +# ============================================================================
 +# EXIT CODES
 +# ============================================================================
++
 +section "8. EXIT CODES"
 +compare_posix_exit_code "true exits 0" "true"
 +compare_posix_exit_code "false exits 1" "false"
 +compare_posix_exit_code "exit 0" "(exit 0)"
 +compare_posix_output "exit code chain" "true; echo \$?"
 +compare_posix_output "backtick vs dollar-paren" "a=\`echo test\`; b=\$(echo test); test \"\$a\" = \"\$b\" && echo same"
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "REDIRECTION GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    exit 1
 +fi
 +exit 0

suites/posix/posix_gaps_special.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Special Parameters Gap Tests
 +# =====================================
 +# Tests for POSIX special parameters and expansion
 +# Split from posix_compliance_gaps.sh for better organization
++
 +# Colors (POSIX-compliant way)
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +NC='\033[0m'
++
 +# Test identification
 +TEST_PREFIX="[gaps-special]"
 +CURRENT_SECTION=""
 +TEST_NUM=0
++
 +PASSED=0
 +FAILED=0
 +SKIPPED=0
 +FAILED_TESTS_LIST=""
 +DEBUG_INFO=""
++
 +# Get script directory (POSIX way)
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
 +FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"
 +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"
 +    exit 1
 +fi
++
 +pass() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    printf "${GREEN}✓ PASS${NC} ${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}: %s\n" "$1"
 +    PASSED=$((PASSED + 1))
 +}
++
 +fail() {
 +    TEST_NUM=$((TEST_NUM + 1))
 +    TEST_ID="${TEST_PREFIX} ${CURRENT_SECTION}.${TEST_NUM}"
 +    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
 +    FAILED=$((FAILED + 1))
 +}
++
 +section() {
 +    CURRENT_SECTION=$(echo "$1" | grep -oE '^[0-9]+' || echo "0")
 +    TEST_NUM=0
 +    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]*: //'; }
++
 +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)
 +    if [ "$posix_out" = "$fortsh_out" ]; then pass "$test_name"
 +    else
 +        fail "$test_name" "$posix_out" "$fortsh_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"
 +    fi
 +}
++
 +# ============================================================================
 +# SPECIAL PARAMETERS
 +# ============================================================================
++
 +section "1. POSITIONAL PARAMETERS"
 +compare_posix_output "dollar at" 'set -- a b c; echo "$@"'
 +compare_posix_output "dollar star" 'set -- a b c; echo "$*"'
 +compare_posix_output "dollar hash" 'set -- a b c; echo $#'
 +compare_posix_output "dollar at with IFS" "IFS=:; set -- a b c; echo \"\$*\""
 +compare_posix_output "dollar star vs at unquoted" "set -- a b c; for x in \$*; do echo \$x; done | wc -l"
 +compare_posix_output "dollar at quoted iteration" "set -- 'a b' 'c d'; for x in \"\$@\"; do echo \$x; done | wc -l"
 +compare_posix_output "dollar hash after shift" "set -- a b c; shift; echo \$#"
++
 +section "2. SHELL STATUS PARAMETERS"
 +compare_posix_output "dollar question" 'true; echo $?'
 +compare_posix_output "dollar pid" 'echo $$ | grep -cE "^[0-9]+$"'
 +compare_posix_output "dollar zero" 'echo $0 | grep -c .'
 +compare_posix_output "dollar dash shows options" "echo \$- | grep -c '[a-z]'"
 +compare_posix_output "dollar dollar is numeric" "echo \$\$ | grep -c '^[0-9]*\$'"
 +compare_posix_output "dollar zero is set" "echo \${0:-none} | grep -c '.'"
++
 +# ============================================================================
 +# PARAMETER EXPANSION
 +# ============================================================================
++
 +section "3. DEFAULT VALUES"
 +compare_posix_output "pe default" 'unset x; echo ${x:-default}'
 +compare_posix_output "pe assign" 'unset x; echo ${x:=assigned}; echo $x'
 +compare_posix_output "pe error" '(unset x; echo ${x:?msg}) 2>/dev/null; echo $?'
 +compare_posix_output "pe alt" 'x=val; echo ${x:+alt}'
 +compare_posix_output "default empty" 'x=""; echo ${x:-default}'
 +compare_posix_output "default unset" 'unset x; echo ${x:-default}'
 +compare_posix_output "default set" 'x="value"; echo ${x:-default}'
++
 +section "4. STRING LENGTH"
 +compare_posix_output "pe length" 'x=hello; echo ${#x}'
 +compare_posix_output "length of empty" 'x=""; echo ${#x}'
 +compare_posix_output "length of one" 'x="a"; echo ${#x}'
 +compare_posix_output "length of special" 'x="a b c"; echo ${#x}'
++
 +section "5. PATTERN REMOVAL"
 +compare_posix_output "pe suffix" 'x=file.txt; echo ${x%.txt}'
 +compare_posix_output "pe prefix" 'x=/path/file; echo ${x##*/}'
 +compare_posix_output "suffix remove" 'x="file.txt"; echo ${x%.txt}'
 +compare_posix_output "prefix remove" 'x="prefix_name"; echo ${x#prefix_}'
 +compare_posix_output "longest suffix" 'x="a.b.c"; echo ${x%%.*}'
 +compare_posix_output "longest prefix" 'x="a.b.c"; echo ${x##*.}'
++
 +section "6. NESTED EXPANSION"
 +compare_posix_output "nested default" "unset A; B=inner; echo \${A:-\${B}}"
 +compare_posix_output "nested length" "VAR=hello; echo \${#VAR}"
 +compare_posix_output "nested pattern removal" "VAR=/usr/local/bin; echo \${VAR#\${VAR%/*}}"
 +compare_posix_output "multiple expansions" "A=foo; B=bar; echo \${A}\${B}"
 +compare_posix_output "nested with quotes" "A='a b'; echo \"\${A}\""
++
 +# ============================================================================
 +# IFS SPLITTING
 +# ============================================================================
++
 +section "7. IFS SPLITTING"
 +compare_posix_output "ifs default" 'x="a b c"; set -- $x; echo $#'
 +compare_posix_output "ifs colon" 'IFS=:; x="a:b:c"; set -- $x; echo $#'
 +compare_posix_output "ifs empty" 'IFS=""; x="abc"; set -- $x; echo $#'
 +compare_posix_output "ifs star" 'IFS=:; set -- a b c; echo "$*"'
++
 +# ============================================================================
 +# COMMAND SUBSTITUTION
 +# ============================================================================
++
 +section "8. COMMAND SUBSTITUTION"
 +compare_posix_output "cmdsub basic" 'echo $(echo hello)'
 +compare_posix_output "cmdsub backtick" 'echo `echo hello`'
 +compare_posix_output "cmdsub nested" 'echo $(echo $(echo deep))'
 +compare_posix_output "cmdsub quoted" 'echo "$(echo hello world)"'
 +compare_posix_output "cmdsub multi" 'echo $(echo a; echo b)'
++
 +section "9. COMMAND SUBSTITUTION VARIANTS"
 +compare_posix_output "cmd sub echo" 'echo $(echo hello)'
 +compare_posix_output "cmd sub pwd" 'echo $(pwd | grep -c "/")'
 +compare_posix_output "cmd sub math" 'echo $(($(echo 5) + 3))'
 +compare_posix_output "cmd sub in var" 'x=$(echo test); echo $x'
 +compare_posix_output "backtick equiv" 'echo `echo hello`'
 +compare_posix_output "cmd sub whitespace" 'echo "$(echo "  spaces  ")"'
 +compare_posix_output "cmd sub multiline" 'echo "$(echo -e "a\nb")" | wc -l'
 +compare_posix_output "cmd sub exit code" '$(exit 0); echo $?'
 +compare_posix_output "cmd sub fail code" '$(exit 1); echo $?'
++
 +# ============================================================================
 +# TILDE EXPANSION
 +# ============================================================================
++
 +section "10. TILDE EXPANSION"
 +compare_posix_output "tilde in assignment" "VAR=~/test; echo \$VAR | grep -c '^/'"
 +compare_posix_output "tilde in middle no expand" "echo a~b | grep -c '~'"
++
 +# ============================================================================
 +# VARIABLE ASSIGNMENT CONTEXTS
 +# ============================================================================
++
 +section "11. VARIABLE ASSIGNMENT"
 +compare_posix_output "simple assign" 'x=5; echo $x'
 +compare_posix_output "multi assign" 'x=1 y=2 z=3; echo $x $y $z'
 +compare_posix_output "assign in subshell" '(x=inner; echo $x); echo ${x:-unset}'
 +compare_posix_output "assign export" 'export X=exported; printenv X 2>/dev/null || echo $X'
 +compare_posix_output "assign readonly" 'readonly X=constant; echo $X'
 +compare_posix_output "assign with cmd" 'X=$(echo value); echo $X'
 +compare_posix_output "assign quoted" 'X="with spaces"; echo "$X"'
 +compare_posix_output "assign empty" 'X=""; echo "[$X]"'
 +compare_posix_output "assign special" 'X="$HOME"; echo ${X:+set}'
++
 +# ============================================================================
 +# PIPELINES
 +# ============================================================================
++
 +section "12. PIPELINES"
 +compare_posix_output "pipe two" 'echo hello | cat'
 +compare_posix_output "pipe three" 'echo hello | cat | cat'
 +compare_posix_output "pipe with grep" 'echo hello | grep -o h'
 +compare_posix_output "pipe word count" 'echo "a b c" | wc -w'
 +compare_posix_output "pipe line count" 'printf "a\nb\nc\n" | wc -l'
 +compare_posix_output "pipe sort" 'printf "c\na\nb\n" | sort | head -1'
 +compare_posix_output "pipe uniq" 'printf "a\na\nb\n" | uniq | wc -l'
 +compare_posix_output "pipe head" 'printf "1\n2\n3\n4\n5\n" | head -2'
 +compare_posix_output "pipe tail" 'printf "1\n2\n3\n4\n5\n" | tail -2'
 +compare_posix_output "pipe tr" 'echo abc | tr a-z A-Z'
++
 +# ============================================================================
 +# COMMAND NAME RESOLUTION
 +# ============================================================================
++
 +section "13. COMMAND NAME RESOLUTION"
 +compare_posix_output "function overrides echo" "echo() { printf 'function\n'; }; echo test | grep -c function"
 +compare_posix_output "command -v finds function" "func() { :; }; command -v func | grep -c func"
 +compare_posix_output "command bypasses function" "echo() { printf 'func\n'; }; command echo test"
++
 +# Summary
 +printf "\n==========================================\n"
 +printf "SPECIAL PARAMETERS GAP TEST RESULTS\n"
 +printf "==========================================\n"
 +printf "${GREEN}Passed:${NC}  %d\n" "$PASSED"
 +printf "${RED}Failed:${NC}  %d\n" "$FAILED"
 +printf "Total:   %d\n" "$((PASSED + FAILED))"
 +if [ "$FAILED" -gt 0 ]; then
 +    printf "\n${RED}Failed tests:${NC}\n%b" "$FAILED_TESTS_LIST"
 +    if [ -n "$DEBUG_INFO" ]; then
 +        printf "\n${YELLOW}Debug info:${NC}\n%b" "$DEBUG_INFO"
 +    fi
 +    exit 1
 +fi
 +exit 0

suites/posix/run_posix_tests.shadded

 +#!/bin/sh
 +# =====================================
 +# POSIX Compliance Test Runner
 +# =====================================
 +# Runs all POSIX compliance test suites for fortsh
 +# Automatically detects fortsh binary location
++
 +set -e
++
 +# Colors
 +RED='\033[0;31m'
 +GREEN='\033[0;32m'
 +YELLOW='\033[1;33m'
 +BLUE='\033[0;34m'
 +CYAN='\033[0;36m'
 +NC='\033[0m'
++
 +# Get script directory
 +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
++
 +# Find fortsh binary - check multiple locations
 +if [ -n "$FORTSH_BIN" ] && [ -x "$FORTSH_BIN" ]; then
 +    # Use environment variable if set
 +    FORTSH_PATH="$FORTSH_BIN"
 +elif [ -x "$SCRIPT_DIR/../bin/fortsh" ]; then
 +    # Look in ../bin/fortsh (relative to tests/)
 +    FORTSH_PATH="$SCRIPT_DIR/../bin/fortsh"
 +elif [ -x "./bin/fortsh" ]; then
 +    # Look in ./bin/fortsh (from project root)
 +    FORTSH_PATH="./bin/fortsh"
 +elif [ -x "$(pwd)/bin/fortsh" ]; then
 +    # Look in current working directory
 +    FORTSH_PATH="$(pwd)/bin/fortsh"
 +else
 +    printf "${RED}ERROR: fortsh binary not found!${NC}\n"
 +    printf "Searched locations:\n"
 +    printf "  - FORTSH_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"
 +    exit 1
 +fi
++
 +export FORTSH_BIN="$FORTSH_PATH"
++
 +# Test suite files
 +TEST_SUITES="
 +posix_compliance_test.sh
 +posix_compliance_extended.sh
 +posix_compliance_builtins.sh
 +posix_compliance_advanced.sh
 +posix_compliance_gaps.sh
 +posix_compliance_jobcontrol.sh
 +posix_compliance_coverage.sh
 +posix_compliance_untested.sh
 +"
++
 +# Print header
 +printf "${CYAN}========================================\n"
 +printf "POSIX Compliance Test Suite Runner\n"
 +printf "========================================${NC}\n"
 +printf "fortsh binary: ${GREEN}%s${NC}\n" "$FORTSH_BIN"
 +printf "Test directory: %s\n" "$SCRIPT_DIR"
 +printf "\n"
++
 +# Counters
 +TOTAL_SUITES=0
 +PASSED_SUITES=0
 +FAILED_SUITES=0
 +TOTAL_TESTS=0
++
 +# Run each test suite
 +for suite in $TEST_SUITES; do
 +    suite_path="$SCRIPT_DIR/$suite"
++
 +    if [ ! -f "$suite_path" ]; then
 +        printf "${YELLOW}⊘ SKIP${NC}: %s (not found)\n" "$suite"
 +        continue
 +    fi
++
 +    if [ ! -x "$suite_path" ]; then
 +        printf "${YELLOW}⊘ SKIP${NC}: %s (not executable)\n" "$suite"
 +        continue
 +    fi
++
 +    TOTAL_SUITES=$((TOTAL_SUITES + 1))
++
 +    printf "${BLUE}========================================\n"
 +    printf "Running: %s\n" "$suite"
 +    printf "========================================${NC}\n"
++
 +    # Run the test suite
 +    if "$suite_path"; then
 +        printf "${GREEN}✓ PASSED${NC}: %s\n\n" "$suite"
 +        PASSED_SUITES=$((PASSED_SUITES + 1))
 +    else
 +        printf "${RED}✗ FAILED${NC}: %s\n\n" "$suite"
 +        FAILED_SUITES=$((FAILED_SUITES + 1))
 +    fi
 +done
++
 +# Print summary
 +printf "${CYAN}========================================\n"
 +printf "OVERALL SUMMARY\n"
 +printf "========================================${NC}\n"
 +printf "Total test suites: %d\n" "$TOTAL_SUITES"
 +printf "${GREEN}Passed suites:     %d${NC}\n" "$PASSED_SUITES"
 +printf "${RED}Failed suites:     %d${NC}\n" "$FAILED_SUITES"
 +printf "${CYAN}========================================${NC}\n"
++
 +if [ "$FAILED_SUITES" -eq 0 ] && [ "$TOTAL_SUITES" -gt 0 ]; then
 +    printf "${GREEN}\n✓ ALL TEST SUITES PASSED!\n${NC}"
 +    exit 0
 +else
 +    printf "${RED}\n✗ SOME TEST SUITES FAILED\n${NC}"
 +    exit 1
 +fi