tenseleyflow/bensch / 8636752

+#!/bin/sh

+TEST_PREFIX="[alias]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. alias basic"

+compare_output "alias define and use via eval" 'shopt -s expand_aliases 2>/dev/null; alias greet="echo hello"; eval greet'

+compare_exit "alias lists all without error" 'alias >/dev/null 2>&1'

+compare_exit "alias nonexistent fails" 'alias nonexistent_alias_xyz 2>/dev/null'

+compare_output "alias with arguments" 'shopt -s expand_aliases 2>/dev/null; alias say="echo"; eval "say hello"'

+

+section "2. unalias"

+compare_exit "unalias removes alias" 'alias greet="echo hello"; unalias greet; alias greet 2>/dev/null'

+compare_exit "unalias -a removes all" 'alias a1="echo 1"; alias a2="echo 2"; unalias -a; alias a1 2>/dev/null'

+compare_exit "unalias nonexistent fails" 'unalias nonexistent_alias_xyz 2>/dev/null'

+

+section "3. alias edge cases"

+compare_output "alias with equals in value" 'shopt -s expand_aliases 2>/dev/null; alias myvar="echo x=1"; eval myvar'

+compare_output "alias with semicolon" 'shopt -s expand_aliases 2>/dev/null; alias both="echo a; echo b"; eval both'

+compare_output "alias preserves original after unalias" 'alias echo="printf ALIAS"; unalias echo; echo hello'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[arithmetic]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. basic arithmetic"

+compare_output "addition" 'echo $((3 + 4))'

+compare_output "subtraction" 'echo $((10 - 3))'

+compare_output "multiplication" 'echo $((6 * 7))'

+compare_output "division" 'echo $((20 / 4))'

+compare_output "modulo" 'echo $((17 % 5))'

+compare_output "negative result" 'echo $((3 - 10))'

+compare_output "zero division guard" 'echo $((0 / 1))'

+

+section "2. operator precedence"

+compare_output "multiply before add" 'echo $((2 + 3 * 4))'

+compare_output "parentheses override" 'echo $(( (2 + 3) * 4 ))'

+compare_output "nested parentheses" 'echo $(( (2 + 3) * (4 - 1) ))'

+compare_output "complex expression" 'echo $(( 10 / 2 + 3 * 4 - 1 ))'

+

+section "3. comparison and ternary"

+compare_output "ternary true" 'echo $((5 > 3 ? 5 : 3))'

+compare_output "ternary false" 'echo $((2 > 3 ? 2 : 3))'

+compare_output "equality" 'echo $((5 == 5))'

+compare_output "inequality" 'echo $((5 != 3))'

+compare_output "less than" 'echo $((3 < 5))'

+compare_output "greater than" 'echo $((5 > 3))'

+compare_output "logical AND" 'echo $((1 && 1))'

+compare_output "logical OR" 'echo $((0 || 1))'

+compare_output "logical NOT" 'echo $((!0))'

+

+section "4. increment and decrement"

+compare_output "post-increment" 'x=5; echo $((x++)); echo $x'

+compare_output "pre-increment" 'x=5; echo $((++x)); echo $x'

+compare_output "post-decrement" 'x=5; echo $((x--)); echo $x'

+compare_output "pre-decrement" 'x=5; echo $((--x)); echo $x'

+

+section "5. bitwise operations"

+compare_output "bitwise AND" 'echo $((12 & 10))'

+compare_output "bitwise OR" 'echo $((12 | 10))'

+compare_output "bitwise XOR" 'echo $((12 ^ 10))'

+compare_output "bitwise NOT" 'echo $((~0))'

+compare_output "left shift" 'echo $((1 << 4))'

+compare_output "right shift" 'echo $((16 >> 2))'

+

+section "6. compound assignment"

+compare_output "+= assignment" 'x=10; echo $((x += 5))'

+compare_output "-= assignment" 'x=10; echo $((x -= 3))'

+compare_output "*= assignment" 'x=4; echo $((x *= 3))'

+compare_output "/= assignment" 'x=20; echo $((x /= 4))'

+compare_output "%= assignment" 'x=17; echo $((x %= 5))'

+

+section "7. variables in arithmetic"

+compare_output "variable reference" 'a=10; b=20; echo $((a + b))'

+compare_output "unset var is zero" 'unset V; echo $((V + 5))'

+compare_output "assignment in expression" 'echo $((x = 5 + 3)); echo $x'

+compare_output "chained assignment" 'echo $((x = y = 5)); echo $x $y'

+compare_output "comma operator" 'echo $((x=1, y=2, x+y))'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[arrays]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. indexed array basics"

+compare_output "array literal assignment" 'arr=(a b c); echo ${arr[0]}'

+compare_output "array second element" 'arr=(a b c); echo ${arr[1]}'

+compare_output "array third element" 'arr=(a b c); echo ${arr[2]}'

+compare_output "array all elements @" 'arr=(a b c); echo ${arr[@]}'

+compare_output "array all elements *" 'arr=(a b c); echo ${arr[*]}'

+compare_output "array length" 'arr=(a b c); echo ${#arr[@]}'

+compare_output "array single element assignment" 'arr[0]=hello; echo ${arr[0]}'

+

+section "2. indexed array operations"

+compare_output "array sparse assignment" 'arr=(); arr[0]=x; arr[5]=y; echo ${arr[5]}'

+compare_output "array indices with !" 'arr=(a b c); arr[5]=d; echo ${!arr[@]}'

+compare_output "array append +=" 'arr=(a b); arr+=(c d); echo ${arr[@]}'

+compare_output "array slice" 'arr=(a b c d e); echo ${arr[@]:1:2}'

+compare_output "array slice to end" 'arr=(a b c d e); echo ${arr[@]:2}'

+compare_output "array unset element" 'arr=(a b c); unset arr[1]; echo ${arr[@]}'

+compare_output "array unset preserves indices" 'arr=(a b c d); unset arr[1]; echo ${!arr[@]}'

+compare_output "array element length" 'arr=(hello world); echo ${#arr[0]}'

+

+section "3. indexed array advanced"

+compare_output "array in for loop" 'arr=(a b c); for x in "${arr[@]}"; do echo $x; done'

+compare_output "array with spaces in elements" 'arr=("hello world" "foo bar"); echo ${arr[0]}'

+compare_output "array reassignment" 'arr=(a b c); arr=(x y); echo ${arr[@]}'

+compare_output "array from command substitution" 'arr=($(echo a b c)); echo ${arr[1]}'

+compare_output "array element modification" 'arr=(a b c); arr[1]=B; echo ${arr[@]}'

+

+section "4. associative array basics"

+compare_output "assoc array set and get" 'declare -A m; m[name]=alice; echo ${m[name]}'

+compare_output "assoc array multiple keys" 'declare -A m; m[a]=1; m[b]=2; m[c]=3; echo ${m[a]} ${m[b]} ${m[c]}'

+compare_output "assoc array count" 'declare -A m; m[a]=1; m[b]=2; m[c]=3; echo ${#m[@]}'

+compare_output "assoc array overwrite key" 'declare -A m; m[k]=old; m[k]=new; echo ${m[k]}'

+compare_output "assoc array unset key" 'declare -A m; m[a]=1; m[b]=2; unset m[a]; echo ${#m[@]}'

+

+section "5. associative array advanced"

+compare_output "assoc array key list sorted" 'declare -A m; m[x]=1; m[y]=2; for k in "${!m[@]}"; do echo "$k"; done | sort'

+compare_output "assoc array value with spaces" 'declare -A m; m[key]="hello world"; echo ${m[key]}'

+compare_output "assoc array numeric keys" 'declare -A m; m[1]=one; m[2]=two; echo ${m[1]} ${m[2]}'

+compare_output "assoc array empty value" 'declare -A m; m[k]=""; echo ">${m[k]}<"'

+compare_output "assoc array in loop" 'declare -A m; m[a]=1; m[b]=2; for v in "${m[@]}"; do echo $v; done | sort'

+compare_output "assoc array quoted key" 'declare -A m; m["my key"]="value"; echo ${m["my key"]}'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[cd-pwd]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. cd basic"

+compare_output "cd no args goes to HOME" 'cd && pwd | tail -1'

+compare_output "cd to absolute /tmp" 'cd /tmp && pwd'

+compare_output "cd to relative subdir" "mkdir -p $TEST_TMPDIR/sub && cd $TEST_TMPDIR && cd sub && pwd"

+compare_exit "cd to nonexistent dir fails" 'cd /nonexistent_dir_xyz_12345'

+compare_exit "cd to nonexistent dir exit code" 'cd /nonexistent_dir_xyz_12345 2>/dev/null'

+compare_output "cd to root" 'cd / && pwd'

+compare_output "cd with trailing slash" 'cd /tmp/ && pwd'

+

+section "2. cd special"

+compare_output "cd - returns to OLDPWD" 'cd /tmp && cd / && cd - 2>/dev/null && pwd'

+compare_output "OLDPWD is set after cd" 'cd /tmp && cd / && echo $OLDPWD'

+compare_output "cd .. parent directory" 'cd /tmp && cd .. && pwd'

+compare_output "cd ../.. grandparent" 'cd /tmp && cd ../.. 2>/dev/null && pwd'

+compare_output "cd . stays in same dir" 'cd /tmp && cd . && pwd'

+

+section "3. pwd"

+compare_output "pwd outputs current dir" 'pwd'

+compare_exit "pwd exits 0" 'pwd'

+compare_output "pwd -L logical path" 'pwd -L'

+compare_output "pwd -P physical path" 'pwd -P'

+

+section "4. cd with CDPATH"

+compare_output "cd with CDPATH" "mkdir -p $TEST_TMPDIR/base/target && CDPATH=$TEST_TMPDIR/base && cd target 2>/dev/null && pwd"

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[declare]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. declare basic flags"

+compare_output "declare -i integer arithmetic" 'declare -i num=5+3; echo $num'

+compare_output "declare -r is readonly" 'declare -r RO=hello; echo $RO'

+compare_exit "declare -r prevents modification" 'declare -r RO=hello; RO=world 2>/dev/null'

+compare_output "declare -x exports variable" 'declare -x MYEXP=exported; '"$BASH_REF"' -c "echo \$MYEXP"'

+compare_output "declare plain variable" 'declare V=hello; echo $V'

+

+section "2. declare arrays"

+compare_output "declare -a indexed array" 'declare -a arr=(a b c); echo ${arr[1]}'

+compare_output "declare -a empty array" 'declare -a arr; arr[0]=x; echo ${arr[0]}'

+compare_output "declare -A associative array" 'declare -A map; map[key]=val; echo ${map[key]}'

+compare_output "declare -A multiple keys" 'declare -A m; m[a]=1; m[b]=2; echo ${m[a]} ${m[b]}'

+compare_output "declare -A overwrite key" 'declare -A m; m[k]=old; m[k]=new; echo ${m[k]}'

+

+section "3. declare listing"

+check_exit "declare -p prints attributes" 'declare -p >/dev/null' "0"

+compare_output "declare without args succeeds" 'declare >/dev/null; echo $?'

+compare_output "declare -p specific var" 'declare -i NUM=42; declare -p NUM'

+

+section "4. declare integer behavior"

+compare_output "declare -i assignment evaluates arithmetic" 'declare -i x; x=2+3; echo $x'

+compare_output "declare -i multiplication" 'declare -i x=3*4; echo $x'

+compare_output "declare -i with variable reference" 'y=10; declare -i x=y+5; echo $x'

+compare_output "declare -i string assigns zero" 'declare -i x=notanumber; echo $x'

+

+section "5. declare combined flags"

+compare_output "declare -ix integer and export" 'declare -ix INTEXP=42; echo $INTEXP'

+compare_output "declare -ri readonly integer" 'declare -ri RINT=42; echo $RINT'

+compare_exit "declare -ri prevents modification" 'declare -ri RINT=42; RINT=99 2>/dev/null'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[echo]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. echo basic"

+compare_output "echo basic string" 'echo hello world'

+compare_output "echo with no arguments" 'echo'

+compare_output "echo with multiple spaced args" 'echo a   b    c'

+compare_output "echo single arg" 'echo hello'

+compare_output "echo preserves quotes in args" 'echo "hello world"'

+compare_output "echo multiple quoted args" 'echo "hello" "world"'

+compare_output "echo with special characters" 'echo "hello*world"'

+compare_output "echo empty string" 'echo ""'

+

+section "2. echo flags"

+compare_output "echo -n suppresses newline" 'echo -n hello'

+compare_output "echo -n with multiple args" 'echo -n hello world'

+compare_output "echo -e interprets backslash-n" 'echo -e "hello\nworld"'

+compare_output "echo -e interprets backslash-t" 'echo -e "hello\tworld"'

+compare_output "echo -e interprets double backslash" 'echo -e "back\\\\slash"'

+compare_output "echo -e interprets backslash-a and backslash-b" 'echo -e "x\b\ay"'

+compare_output "echo -E disables escape interpretation" 'echo -E "hello\nworld"'

+compare_output "echo -en combines flags" 'echo -en "hello\nworld"'

+compare_output "echo -ne combines flags reversed" 'echo -ne "hello\tworld"'

+

+section "3. echo edge cases"

+compare_output "echo dash-dash is literal" 'echo -- hello'

+compare_output "echo treats unknown flag as text" 'echo -z hello'

+compare_output "echo -e with \\c truncates" 'echo -e "hello\cworld"'

+compare_output "echo -e with \\0NNN octal" 'echo -e "\0101"'

+compare_output "echo -e with \\xNN hex" 'echo -e "\x41"'

+compare_output "echo preserves trailing spaces in quotes" 'echo "hello   "'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[eval]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. eval basic"

+compare_output "eval basic echo" "eval 'echo hello'"

+compare_output "eval with variable expansion" 'X=world; eval "echo hello $X"'

+compare_output "eval constructs command from parts" 'CMD="echo"; ARG="hello"; eval "$CMD $ARG"'

+compare_output "eval with multiple statements" 'eval "echo one; echo two"'

+

+section "2. eval exit codes"

+compare_exit "eval preserves exit code 0" "eval 'true'"

+compare_exit "eval preserves exit code 1" "eval 'false'"

+compare_exit "eval exit with specific code" "eval 'exit 42'"

+compare_output "eval captures $?" 'eval "true"; echo $?'

+

+section "3. eval compound commands"

+compare_output "eval for loop" "eval 'for i in a b c; do echo \$i; done'"

+compare_output "eval if statement" 'eval "if true; then echo yes; fi"'

+compare_output "eval pipeline" 'eval "echo hello | tr h H"'

+

+section "4. eval edge cases"

+compare_output "eval empty string" 'eval ""; echo $?'

+compare_output "eval variable indirection" 'name=VAR; VAR=hello; eval "echo \$$name"'

+compare_output "eval with quoting layers" "eval 'echo '\"'\"'hello'\"'\"''"

+compare_output "eval nested" 'eval eval "echo hello"'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[exec]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. exec replaces shell"

+compare_output "exec replaces shell with command" 'exec echo replaced'

+compare_exit "exec replaces shell exit code true" 'exec true'

+compare_exit "exec replaces shell exit code false" 'exec false'

+compare_output "exec nothing after exec runs" 'exec echo hello; echo unreachable'

+compare_output "exec with arguments" 'exec echo one two three'

+compare_exit "exec nonexistent command fails" 'exec /nonexistent_cmd_xyz 2>/dev/null'

+

+section "2. exec with redirections only"

+compare_output "exec redirect fd to /dev/null" "exec 3>/dev/null; echo ok"

+compare_output "exec redirect fd to file" "exec 3>$TEST_TMPDIR/execout; echo hello >&3; exec 3>&-; cat $TEST_TMPDIR/execout"

+compare_output "exec input redirect from file" "echo data > $TEST_TMPDIR/execin; exec 3<$TEST_TMPDIR/execin; read line <&3; echo \$line"

+compare_output "exec close fd" "exec 3>$TEST_TMPDIR/execout; exec 3>&-; echo ok"

+compare_output "exec redirect stdout" "exec >$TEST_TMPDIR/execstdout; echo captured; exec >/dev/tty 2>/dev/null; cat $TEST_TMPDIR/execstdout"

+compare_output "exec redirect stderr" "exec 2>$TEST_TMPDIR/execstderr; echo err >&2; exec 2>/dev/tty 2>/dev/null; cat $TEST_TMPDIR/execstderr"

+

+section "3. exec in subshell"

+compare_output "exec in subshell does not affect parent" '(exec echo sub); echo parent'

+compare_exit "exec in subshell exit code" '(exec false)'

+

+section "4. exec preserves environment"

+compare_output "exec preserves exported vars" 'export MYVAR=hello; exec echo $MYVAR'

+compare_output "exec with PATH lookup" 'exec ls /dev/null'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[export-unset]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. export"

+compare_output "export VAR=value" 'export MYVAR=hello; echo $MYVAR'

+compare_output "export preserves in subshell" 'export MYVAR=hello; '"$BASH_REF"' -c "echo \$MYVAR"'

+compare_output "export without value marks for export" 'MYVAR=test; export MYVAR; '"$BASH_REF"' -c "echo \$MYVAR"'

+compare_output "export multiple vars" 'export A=1 B=2 C=3; echo $A $B $C'

+compare_exit "export -p succeeds" 'export -p'

+compare_output "export overwrites existing" 'export V=old; export V=new; echo $V'

+compare_output "unexported var not in subshell" 'MYVAR=local; '"$BASH_REF"' -c "echo \${MYVAR:-empty}"'

+compare_output "export -n unexports variable" 'export MYVAR=hello; export -n MYVAR; '"$BASH_REF"' -c "echo \${MYVAR:-gone}"'

+

+section "2. unset"

+compare_output "unset removes variable" 'MYVAR=hello; unset MYVAR; echo ">${MYVAR}<"'

+compare_exit "unset nonexistent var succeeds" 'unset NONEXISTENT_VAR_XYZ_99'

+compare_output "unset -v removes variable" 'MYVAR=hello; unset -v MYVAR; echo ">${MYVAR}<"'

+compare_output "unset -f removes function" 'f() { echo hi; }; unset -f f; f 2>/dev/null; echo $?'

+compare_output "unset multiple vars" 'A=1; B=2; C=3; unset A C; echo ">${A}< ${B} >${C}<"'

+compare_output "unset array" 'arr=(a b c); unset arr; echo ">${arr[@]}<"'

+

+section "3. printenv"

+compare_output "printenv specific var" 'export MYVAR=hello; printenv MYVAR'

+compare_exit "printenv nonexistent var fails" 'printenv NONEXISTENT_VAR_XYZ_99'

+compare_exit "printenv with no args succeeds" 'printenv >/dev/null'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[fc]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. fc listing"

+check_exit "fc -l lists history" 'fc -l' "0"

+check_exit "fc -l -n suppresses line numbers" 'fc -l -n' "0"

+check_exit "fc -l -r reverses order" 'fc -l -r' "0"

+skip "fc -l produces output" "requires interactive mode (no history in -c)"

+

+section "2. fc with range"

+check_exit "fc -l with negative offset" 'fc -l -5 2>/dev/null; true' "0"

+check_exit "fc -l first last range" 'fc -l 1 5 2>/dev/null; true' "0"

+check_exit "fc -l with prefix search" 'echo hello; fc -l echo 2>/dev/null; true' "0"

+

+section "3. fc flags combined"

+check_exit "fc -l -n combined" 'fc -l -n 2>/dev/null; true' "0"

+check_exit "fc -l -r -n all combined" 'fc -l -r -n 2>/dev/null; true' "0"

+

+section "4. fc substitution"

+compare_output "fc -s re-executes" 'echo testcmd123; fc -s echo 2>/dev/null || true'

+check_exit "fc -s with no history" 'fc -s nonexistent_xyz 2>/dev/null; true' "0"

+

+section "5. fc editor"

+check_exit "fc -e with EDITOR" 'FCEDIT=/bin/true; fc -e /bin/true 2>/dev/null; true' "0"

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[flow-control]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. exit"

+compare_exit "exit 0" 'exit 0'

+compare_exit "exit 1" 'exit 1'

+compare_exit "exit 42" 'exit 42'

+compare_exit "exit no arg uses last status" 'false; exit'

+compare_exit "exit 255 wraps" 'exit 255'

+

+section "2. return"

+compare_output "return from function" 'f() { echo before; return; echo after; }; f'

+compare_exit "return with code" 'f() { return 5; }; f'

+compare_output "return preserves code" 'f() { return 3; }; f; echo $?'

+compare_output "return only affects function" 'f() { return 0; }; f; echo after'

+compare_exit "return outside function fails" 'return 0 2>/dev/null'

+

+section "3. break"

+compare_output "break exits loop" 'for i in 1 2 3 4 5; do if [ $i -eq 3 ]; then break; fi; echo $i; done'

+compare_output "break in while loop" 'i=0; while true; do i=$((i+1)); if [ $i -eq 3 ]; then break; fi; echo $i; done'

+compare_output "break N exits nested loops" 'for i in 1 2; do for j in a b; do if [ "$j" = "b" ]; then break 2; fi; echo "$i$j"; done; done'

+compare_output "break 1 same as break" 'for i in 1 2 3; do if [ $i -eq 2 ]; then break 1; fi; echo $i; done'

+compare_output "break from inner loop only" 'for i in 1 2; do for j in a b c; do if [ "$j" = "b" ]; then break; fi; echo "$i$j"; done; echo "outer$i"; done'

+

+section "4. continue"

+compare_output "continue skips iteration" 'for i in 1 2 3 4 5; do if [ $i -eq 3 ]; then continue; fi; echo $i; done'

+compare_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_output "continue N in nested loops" 'for i in 1 2; do for j in a b c; do if [ "$j" = "b" ]; then continue 2; fi; echo "$i$j"; done; done'

+compare_output "continue 1 same as continue" 'for i in 1 2 3; do if [ $i -eq 2 ]; then continue 1; fi; echo $i; done'

+

+section "5. colon and true/false"

+compare_exit ": is no-op with exit 0" ':'

+compare_exit "true exits 0" 'true'

+compare_exit "false exits 1" 'false'

+compare_exit ": with arguments still exits 0" ': some args here'

+compare_output ": does not produce output" ': hello; echo $?'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[getopts]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. getopts basic"

+compare_output "getopts basic option parsing" 'f() { while getopts "ab:c" opt; do echo "$opt"; done; }; f -a -c'

+compare_output "getopts with option argument" 'f() { while getopts "a:b" opt; do echo "$opt=$OPTARG"; done; }; f -a value'

+compare_output "getopts OPTIND tracks position" 'f() { OPTIND=1; while getopts "ab" opt; do :; done; echo $OPTIND; }; f -a -b'

+compare_output "getopts single option" 'f() { while getopts "x" opt; do echo "$opt"; done; }; f -x'

+compare_output "getopts no options given" 'f() { getopts "ab" opt; echo $?; }; f'

+

+section "2. getopts combined and multiple"

+compare_output "getopts combined flags" 'f() { while getopts "abc" opt; do echo "$opt"; done; }; f -abc'

+compare_output "getopts with remaining args" 'f() { OPTIND=1; while getopts "a" opt; do echo "$opt"; done; shift $((OPTIND-1)); echo "$1"; }; f -a hello'

+compare_output "getopts OPTARG for colon option" 'f() { while getopts "a:" opt; do echo "$OPTARG"; done; }; f -a myval'

+compare_output "getopts multiple options with args" 'f() { while getopts "a:b:c" opt; do echo "$opt=$OPTARG"; done; }; f -a one -b two -c'

+compare_output "getopts option arg attached" 'f() { while getopts "n:" opt; do echo "$OPTARG"; done; }; f -n5'

+

+section "3. getopts error handling"

+compare_output "getopts unknown option" 'f() { while getopts "ab" opt 2>/dev/null; do echo "$opt"; done; }; f -c'

+compare_output "getopts silent mode unknown" 'f() { while getopts ":ab" opt; do echo "$opt"; done; }; f -c'

+compare_output "getopts silent mode missing arg" 'f() { while getopts ":a:" opt; do echo "$opt=$OPTARG"; done; }; f -a'

+compare_exit "getopts returns 1 when done" 'f() { set -- -a; getopts "a" opt; getopts "a" opt; echo $?; }; f'

+

+section "4. getopts OPTIND reset"

+compare_output "getopts OPTIND reset between calls" 'f() { OPTIND=1; while getopts "a" opt; do echo "$opt"; done; }; f -a; f -a'

+compare_output "getopts preserves non-option args" 'f() { OPTIND=1; while getopts "v" opt; do echo "$opt"; done; shift $((OPTIND-1)); echo "$@"; }; f -v arg1 arg2'

+compare_output "getopts double-dash stops parsing" 'f() { OPTIND=1; while getopts "a" opt; do echo "$opt"; done; shift $((OPTIND-1)); echo "$@"; }; f -a -- -b'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[hash]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. hash basic"

+check_exit "hash with no args" 'hash' "0"

+check_exit "hash -r clears cache" 'hash -r' "0"

+compare_exit "hash specific command" 'hash ls'

+compare_exit "hash nonexistent command fails" 'hash nonexistent_cmd_xyz_999 2>/dev/null'

+compare_output "hash -r then lookup" 'hash -r; hash ls 2>/dev/null; echo $?'

+

+section "2. hash caching behavior"

+compare_output "hash caches after use" 'ls >/dev/null; hash -t ls 2>/dev/null || hash ls 2>/dev/null; echo $?'

+compare_output "hash -r clears then miss" 'ls >/dev/null; hash -r; hash -t ls 2>/dev/null; echo $?'

+compare_output "hash multiple commands" 'ls >/dev/null; cat /dev/null; hash ls cat 2>/dev/null; echo $?'

+

+section "3. hash error handling"

+compare_exit "hash nonexistent gives error" 'hash no_such_cmd_xyz 2>/dev/null'

+compare_output "hash after PATH change" 'hash ls 2>/dev/null; PATH=""; hash -t ls 2>/dev/null; echo $?'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[history]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. history display"

+check_exit "history runs without error" 'history' "0"

+check_exit "history N shows last N" 'history 5' "0"

+skip "history produces numbered output" "requires interactive mode (no history in -c)"

+

+section "2. history management"

+check_exit "history -c clears history" 'history -c' "0"

+compare_output "history -c then history shows empty" 'history -c; history | wc -l | tr -d " "'

+check_exit "history -d deletes entry" 'history -d 1 2>/dev/null' "0"

+

+section "3. history file operations"

+check_exit "history -w writes to file" "HISTFILE=$TEST_TMPDIR/hist_test; history -w" "0"

+check_exit "history -r reads from file" "HISTFILE=$TEST_TMPDIR/hist_test; history -r" "0"

+check_exit "history -a appends to file" "HISTFILE=$TEST_TMPDIR/hist_test; history -a" "0"

+check_output "history -w creates file" "HISTFILE=$TEST_TMPDIR/hist_w; history -w; test -f $TEST_TMPDIR/hist_w && echo yes" "yes"

+skip "history -w then -r round-trip" "requires interactive mode (no history in -c)"

+

+section "4. history HISTSIZE"

+skip "HISTSIZE limits history" "requires interactive mode (no history in -c)"

+

+section "5. history edge cases"

+check_exit "history with invalid flag" 'history --invalid 2>/dev/null; true' "0"

+check_exit "history 0 shows nothing" 'history 0' "0"

+check_exit "history negative number" 'history -1 2>/dev/null; true' "0"

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[jobs-fg-bg]"

+

+# Job control tests require a PTY — skip in CI/non-interactive mode

+if [ ! -t 0 ] && [ -z "$FORCE_JOB_TESTS" ]; then

+    echo "Passed:  0"

+    echo "Failed:  0"

+    echo "Skipped: 0"

+    echo "Total:   0"

+    exit 0

+fi

+

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. jobs display"

+check_exit "jobs with no background jobs" 'jobs' "0"

+compare_output "jobs shows background process" 'sleep 60 & jobs; kill %1 2>/dev/null; wait 2>/dev/null'

+check_exit "jobs -p shows PIDs" 'sleep 60 & jobs -p >/dev/null; kill %1 2>/dev/null; wait 2>/dev/null' "0"

+compare_output "jobs after completion" 'true & wait; jobs'

+compare_output "jobs shows multiple" 'sleep 60 & sleep 60 & jobs | wc -l | tr -d " "; kill %1 %2 2>/dev/null; wait 2>/dev/null'

+compare_output "jobs -p output is numeric" 'sleep 60 & jobs -p | grep -qE "^[0-9]+$" && echo yes; kill %1 2>/dev/null; wait 2>/dev/null'

+

+section "2. fg"

+compare_exit "fg with no jobs fails" 'fg 2>/dev/null'

+compare_output "fg brings job to foreground" 'sleep 0.1 & fg %1 >/dev/null 2>&1; echo $?'

+compare_exit "fg invalid job spec fails" 'fg %99 2>/dev/null'

+

+section "3. bg"

+compare_exit "bg with no stopped jobs fails" 'bg 2>/dev/null'

+compare_exit "bg invalid job spec fails" 'bg %99 2>/dev/null'

+

+section "4. job spec parsing"

+compare_output "kill by job spec %1" 'sleep 60 & kill %1 2>/dev/null; wait 2>/dev/null; echo done'

+compare_output "multiple background jobs" 'sleep 60 & sleep 60 & kill %1 %2 2>/dev/null; wait 2>/dev/null; echo done'

+compare_output "job numbering sequential" 'sleep 60 & sleep 60 & sleep 60 & kill %1 %2 %3 2>/dev/null; wait 2>/dev/null; echo done'

+

+section "5. background execution"

+compare_output "command runs in background" '(echo bg_done) & wait; echo fg_done'

+compare_output "background preserves exit" '(exit 42) & wait $!; echo $?'

+compare_output "dollar-bang tracks PID" 'sleep 0.1 & test -n "$!" && echo yes'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[kill-wait]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. kill signals"

+check_exit "kill -l lists signals" 'kill -l' "0"

+compare_exit "kill nonexistent PID fails" 'kill -0 999999 2>/dev/null'

+compare_output "kill -l output has TERM" 'kill -l | grep -q TERM && echo yes'

+compare_output "kill -0 checks process exists" 'sleep 60 & pid=$!; kill -0 $pid && echo alive; kill $pid; wait $pid 2>/dev/null'

+compare_output "kill sends TERM by default" 'sleep 60 & pid=$!; kill $pid; wait $pid 2>/dev/null; echo done'

+compare_output "kill -9 sends SIGKILL" 'sleep 60 & pid=$!; kill -9 $pid; wait $pid 2>/dev/null; echo done'

+compare_output "kill -s TERM sends TERM" 'sleep 60 & pid=$!; kill -s TERM $pid; wait $pid 2>/dev/null; echo done'

+compare_exit "kill with invalid signal" 'kill -INVALID 1 2>/dev/null'

+

+section "2. wait basic"

+compare_output "wait for background job" 'echo start; true & wait; echo done'

+compare_exit "wait returns bg exit status 0" 'true & wait $!'

+compare_exit "wait returns bg exit status 1" 'false & wait $!'

+compare_output "wait with no bg jobs succeeds" 'wait; echo $?'

+compare_exit "wait specific PID" 'sleep 0.1 & wait $!'

+

+section "3. wait multiple"

+compare_output "wait all background jobs" 'true & true & wait; echo done'

+compare_output "wait specific among multiple" 'sleep 0.1 & p1=$!; sleep 0.1 & p2=$!; wait $p1; echo "p1=$?"; wait $p2; echo "p2=$?"'

+compare_exit "wait for already-exited process" 'true & pid=$!; sleep 0.1; wait $pid'

+

+section "4. wait exit status"

+compare_output "wait captures exit 42" '(exit 42) & wait $!; echo $?'

+compare_output "wait captures exit 0" '(exit 0) & wait $!; echo $?'

+compare_output "dollar-bang is last bg PID" 'sleep 0.1 & echo $! | grep -qE "^[0-9]+$" && echo valid'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[local]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. local scope"

+compare_output "local restricts scope to function" 'f() { local x=inner; echo $x; }; f; echo ">${x}<"'

+compare_output "local with initial value" 'f() { local msg=hello; echo $msg; }; f'

+compare_output "local does not leak outside" 'f() { local secret=42; }; f; echo ">${secret}<"'

+compare_output "local shadows outer variable" 'x=outer; f() { local x=inner; echo $x; }; f; echo $x'

+compare_exit "local outside function fails" 'local x=5 2>/dev/null'

+

+section "2. local advanced"

+compare_output "local without value" 'f() { local x; echo ">${x}<"; }; f'

+compare_output "local multiple vars" 'f() { local a=1 b=2; echo $a $b; }; f'

+compare_output "local preserves outer after return" 'x=outer; f() { local x=inner; return; }; f; echo $x'

+compare_output "nested function locals" 'g() { local x=inner2; echo $x; }; f() { local x=inner1; g; echo $x; }; f'

+compare_output "local in nested calls" 'x=global; f() { local x=f_val; g; echo $x; }; g() { echo $x; }; f; echo $x'

+

+section "3. local with types"

+compare_output "local -i integer" 'f() { local -i n=5+3; echo $n; }; f'

+compare_output "local -a array" 'f() { local -a arr=(a b c); echo ${arr[@]}; }; f'

+compare_output "local -r readonly" 'f() { local -r x=fixed; echo $x; }; f'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[printf]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. printf format specifiers"

+compare_output "printf %s string" 'printf "%s\n" hello'

+compare_output "printf %d decimal" 'printf "%d\n" 42'

+compare_output "printf %x hex lowercase" 'printf "%x\n" 255'

+compare_output "printf %X hex uppercase" 'printf "%X\n" 255'

+compare_output "printf %o octal" 'printf "%o\n" 8'

+compare_output "printf %c character" 'printf "%c\n" A'

+compare_output "printf %i integer" 'printf "%i\n" 42'

+

+section "2. printf width and precision"

+compare_output "printf left-aligned %-10s" 'printf "[%-10s]\n" hi'

+compare_output "printf right-aligned %10s" 'printf "[%10s]\n" hi'

+compare_output "printf precision truncate %.5s" 'printf "%.5s\n" "hello world"'

+compare_output "printf zero-padded %05d" 'printf "%05d\n" 42'

+compare_output "printf width with string %8s" 'printf "[%8s]\n" "abc"'

+compare_output "printf negative number" 'printf "%d\n" -5'

+

+section "3. printf escape sequences"

+compare_output "printf newline in format" 'printf "a\nb\n"'

+compare_output "printf tab in format" 'printf "a\tb\n"'

+compare_output "printf backslash in format" 'printf "a\\\\b\n"'

+compare_output "printf carriage return" 'printf "hello\rworld\n"'

+compare_output "printf literal percent" 'printf "100%%\n"'

+

+section "4. printf multiple args and %b"

+compare_output "printf recycles format for multiple args" 'printf "%s\n" a b c'

+compare_output "printf %b interprets escapes in arg" 'printf "%b\n" "hello\nworld"'

+compare_output "printf multiple %s in format" 'printf "%s=%s\n" key val'

+compare_output "printf mixed format" 'printf "%s is %d\n" age 25'

+

+section "5. printf error handling"

+compare_exit "printf missing format string" 'printf'

+compare_output "printf missing arg uses default" 'printf "%s %d\n"'

+compare_output "printf extra args recycle" 'printf "%s\n" a b c d'

+check_output "printf %d with non-numeric arg" 'printf "%d\n" abc 2>&1' "fortsh: printf: abc: invalid number

+0"

+

+section "6. printf special formats"

+compare_output "printf %q shell-quoted string" 'printf "%q\n" "hello world"'

+compare_output "printf octal escape in format" 'printf "\101\n"'

+compare_output "printf hex escape in format" 'printf "\x41\n"'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[pushd-popd-dirs]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. pushd basic"

+compare_output "pushd changes directory" 'pushd /tmp >/dev/null && pwd'

+compare_output "pushd prints stack" 'pushd /tmp 2>/dev/null'

+compare_output "pushd to HOME with tilde" 'pushd /tmp >/dev/null; pushd ~ >/dev/null && pwd'

+compare_exit "pushd to nonexistent dir fails" 'pushd /nonexistent_xyz_12345 2>/dev/null'

+compare_output "pushd swaps top two with no arg" 'pushd /tmp >/dev/null; pushd /var >/dev/null; pushd >/dev/null; pwd'

+compare_output "pushd -n suppresses cd" 'cd /tmp; pushd -n /var 2>/dev/null; pwd'

+compare_output "pushd to root" 'pushd / >/dev/null && pwd'

+compare_output "pushd multiple dirs" 'pushd /tmp >/dev/null; pushd /var >/dev/null; pushd / >/dev/null; pwd'

+

+section "2. popd basic"

+compare_output "popd returns to previous dir" 'pushd /tmp >/dev/null; pushd /var >/dev/null; popd >/dev/null; pwd'

+compare_exit "popd on empty stack fails" 'popd 2>/dev/null'

+compare_output "popd -n suppresses cd" 'pushd /tmp >/dev/null; pushd /var >/dev/null; popd -n >/dev/null; pwd'

+compare_output "multiple pushd then popd" 'pushd /tmp >/dev/null; pushd /var >/dev/null; pushd / >/dev/null; popd >/dev/null; popd >/dev/null; pwd'

+compare_output "popd all the way back" 'ORIG=$(pwd); pushd /tmp >/dev/null; pushd /var >/dev/null; popd >/dev/null; popd >/dev/null; pwd'

+

+section "3. popd with index"

+compare_output "popd +0 removes top" 'pushd /tmp >/dev/null; pushd /var >/dev/null; popd +0 >/dev/null; pwd'

+compare_output "popd +1 removes second" 'pushd /tmp >/dev/null; pushd /var >/dev/null; popd +1 >/dev/null 2>/dev/null; pwd'

+

+section "4. dirs"

+compare_exit "dirs shows current dir" 'dirs'

+compare_output "dirs -c clears stack" 'pushd /tmp >/dev/null; dirs -c; dirs'

+compare_output "dirs -p one per line" 'pushd /tmp >/dev/null; dirs -p'

+compare_output "dirs -v numbered" 'pushd /tmp >/dev/null; dirs -v'

+compare_output "dirs after pushd shows stack" 'pushd /tmp >/dev/null; pushd /var >/dev/null; dirs'

+compare_output "dirs -l long format" 'pushd /tmp >/dev/null; dirs -l'

+compare_output "dirs with no stack shows cwd" 'dirs -c; dirs'

+

+section "5. directory stack round-trip"

+compare_output "pushd/popd preserves original" 'ORIG=$(pwd); pushd /tmp >/dev/null; pushd /var >/dev/null; popd >/dev/null; popd >/dev/null; test "$(pwd)" = "$ORIG" && echo yes'

+compare_output "deep stack round-trip" 'ORIG=$(pwd); pushd /tmp >/dev/null; pushd /var >/dev/null; pushd / >/dev/null; popd >/dev/null; popd >/dev/null; popd >/dev/null; test "$(pwd)" = "$ORIG" && echo yes'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[read]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. read basic"

+compare_output "read from herestring" 'read VAR <<< "hello"; echo $VAR'

+compare_output "read multiple vars" 'read A B C <<< "one two three"; echo "$A|$B|$C"'

+compare_output "read excess into last var" 'read A B <<< "one two three four"; echo "$A|$B"'

+compare_output "read single var gets all" 'read LINE <<< "hello world test"; echo "$LINE"'

+compare_output "read with empty input" 'read VAR <<< ""; echo ">${VAR}<"'

+

+section "2. read flags"

+compare_output "read -r preserves backslash" 'read -r VAR <<< "hello\\world"; echo "$VAR"'

+compare_output "read without -r interprets backslash" 'read VAR <<< "hello\\\\world"; echo "$VAR"'

+compare_output "read -a into array" 'read -a ARR <<< "a b c"; echo ${ARR[0]} ${ARR[1]} ${ARR[2]}'

+compare_output "read -a array length" 'read -a ARR <<< "x y z"; echo ${#ARR[@]}'

+

+section "3. read with IFS"

+compare_output "read with colon IFS" 'IFS=: read A B C <<< "x:y:z"; echo "$A|$B|$C"'

+compare_output "read with comma IFS" 'IFS=, read A B C <<< "a,b,c"; echo "$A|$B|$C"'

+compare_output "read with custom IFS excess" 'IFS=: read A B <<< "x:y:z"; echo "$A|$B"'

+compare_output "read with space IFS default" 'read A B <<< "  hello   world  "; echo ">$A<>$B<"'

+

+section "4. read from heredoc"

+compare_output "read from heredoc" 'read VAR << EOF

+hello

+EOF

+echo $VAR'

+compare_output "read loop from heredoc" 'while read line; do echo "got:$line"; done << EOF

+alpha

+beta

+EOF'

+

+section "5. read edge cases"

+compare_exit "read with no input returns 1" 'echo -n "" | read VAR'

+compare_output "read preserves whitespace with IFS empty" 'IFS= read line <<< "  spaces  "; echo ">$line<"'

+compare_output "read -r with trailing backslash" 'read -r VAR <<< "end\\"; echo "$VAR"'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[readonly]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. readonly basic"

+compare_output "readonly VAR=value preserves value" 'readonly MYRO=hello; echo $MYRO'

+compare_output "readonly existing var" 'MYVAR=test; readonly MYVAR; echo $MYVAR'

+compare_output "readonly with empty value" 'readonly MYRO=""; echo ">${MYRO}<"'

+compare_output "readonly multiple vars" 'readonly A=1 B=2; echo $A $B'

+

+section "2. readonly enforcement"

+compare_exit "modify readonly var fails" 'readonly MYRO=hello; MYRO=world 2>/dev/null'

+compare_exit "unset readonly var fails" 'readonly MYRO=hello; unset MYRO 2>/dev/null'

+compare_output "readonly var in subshell" 'readonly MYRO=hello; echo $MYRO'

+compare_exit "export readonly var succeeds" 'readonly MYRO=hello; export MYRO 2>/dev/null'

+

+section "3. readonly listing"

+check_exit "readonly -p lists vars" 'readonly -p' "0"

+compare_output "readonly -p shows declared vars" 'readonly TESTRO=abc; readonly -p | grep TESTRO'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[set-shopt]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. set options"

+compare_exit "set -e exits on error" 'set -e; false'

+compare_output "set -e does not exit on conditional" 'set -e; if false; then echo no; fi; echo ok'

+compare_exit "set -u errors on unset var" 'set -u; echo ${NONEXISTENT_XYZ_999} 2>/dev/null'

+compare_exit "set -u triggers failure for unset" 'set -u; echo $NONEXISTENT_XYZ_999 2>/dev/null'

+compare_exit "set -o pipefail catches pipe failure" 'set -o pipefail; false | true'

+compare_output "set -o pipefail success" 'set -o pipefail; true | true; echo $?'

+

+section "2. set positional parameters"

+compare_output "set -- sets positional params" 'set -- a b c; echo $1 $2 $3'

+compare_output "set -- count" 'set -- x y z; echo $#'

+compare_output "set -- overwrites previous" 'set -- a b; set -- x y z; echo $1 $#'

+compare_output "set -- empty clears params" 'set -- a b c; set --; echo $#'

+compare_output "set -- with special chars" 'set -- "hello world" foo; echo "$1"'

+compare_output "dollar-at expansion" 'set -- a b c; for x in "$@"; do echo $x; done'

+compare_output "dollar-star expansion" 'set -- a b c; echo "$*"'

+

+section "3. dollar-dash options string"

+compare_output "dollar-dash shows options" 'set -u; case $- in *u*) echo yes;; *) echo no;; esac'

+

+section "4. shopt"

+check_exit "shopt -s extglob" 'shopt -s extglob 2>/dev/null; echo done' "0"

+compare_exit "shopt -q queries option" 'shopt -q login_shell 2>/dev/null; true'

+compare_exit "shopt -u unsets option" 'shopt -s extglob 2>/dev/null; shopt -u extglob 2>/dev/null; true'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[shift]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+section "1. shift basic"

+compare_output "shift removes first param" 'set -- a b c; shift; echo $1'

+compare_output "shift updates count" 'set -- a b c; shift; echo $#'

+compare_output "shift N removes N params" 'set -- a b c d e; shift 2; echo $1'

+compare_output "shift all params" 'set -- a b c; shift 3; echo $#'

+compare_output "shift preserves remaining" 'set -- a b c d; shift 2; echo "$@"'

+

+section "2. shift edge cases"

+compare_exit "shift past available params fails" 'set -- a; shift 5 2>/dev/null'

+compare_output "shift 0 is no-op" 'set -- a b c; shift 0; echo $1'

+compare_output "shift in loop" 'set -- a b c; while [ $# -gt 0 ]; do echo $1; shift; done'

+compare_output "shift with no params" 'set --; shift 2>/dev/null; echo $#'

+compare_output "multiple shifts" 'set -- a b c d e; shift; shift; echo $1 $#'

+

+print_summary

+#!/bin/sh

+TEST_PREFIX="[source]"

+. "$(cd "$(dirname "$0")" && pwd)/test_harness.sh"

+

+# Create test files

+printf 'SOURCED_VAR=hello\n' > "$TEST_TMPDIR/source_var.sh"

+printf 'greet() { echo "hi $1"; }\n' > "$TEST_TMPDIR/source_func.sh"

+printf 'echo "arg1=$1 arg2=$2"\n' > "$TEST_TMPDIR/source_args.sh"

+printf 'X=10\nY=20\necho $((X + Y))\n' > "$TEST_TMPDIR/source_multi.sh"

+printf 'return 42\n' > "$TEST_TMPDIR/source_return.sh"

+

+section "1. source basic"

+compare_output "source file sets variable" "source $TEST_TMPDIR/source_var.sh; echo \$SOURCED_VAR"

+compare_output "source file defines function" "source $TEST_TMPDIR/source_func.sh; greet world"

+compare_exit "source nonexistent file fails" "source $TEST_TMPDIR/no_such_file.sh 2>/dev/null"

+compare_output "source with arguments" "source $TEST_TMPDIR/source_args.sh foo bar"

+compare_output "source multiple assignments" "source $TEST_TMPDIR/source_multi.sh"

+

+section "2. dot command"

+compare_output "dot command works like source" ". $TEST_TMPDIR/source_var.sh; echo \$SOURCED_VAR"

+compare_output "dot with function def" ". $TEST_TMPDIR/source_func.sh; greet user"

+compare_exit "dot nonexistent file fails" ". $TEST_TMPDIR/no_such_file.sh 2>/dev/null"

+

+section "3. source edge cases"

+compare_exit "source file with return" "source $TEST_TMPDIR/source_return.sh"

+compare_output "source preserves env" "A=before; printf 'A=after\n' > $TEST_TMPDIR/s.sh; source $TEST_TMPDIR/s.sh; echo \$A"

+compare_output "source in function" "f() { source $TEST_TMPDIR/source_var.sh; echo \$SOURCED_VAR; }; f"

+

+print_summary

+#!/bin/sh

+# ============================================================

+# Stress tests for allocatable string / widened buffer changes

+# ============================================================

+# These tests verify that fortsh handles large values, deep

+# nesting, many variables, and boundary conditions correctly

+# after the MAX_VAR_VALUE_LEN 1024->4096 refactoring.

+#

+# Tests marked with skip() are known pre-existing issues not

+# related to the buffer refactoring.

+

+TEST_PREFIX="STRESS"

+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)

+. "$SCRIPT_DIR/test_harness.sh"

+

+# Platform-aware timeouts: ARM64 (flang-new) is ~300x slower on loops

+case "$(uname -m)" in

+  arm64|aarch64) TEST_TIMEOUT=90 ;;

+  *)             TEST_TIMEOUT=30 ;;

+esac

+

+# ==========================================

+# 1. Long variable values

+# ==========================================

+section "1 - Long variable values"

+

+compare_output "2000-char variable via printf %0*d" \

+  'x=$(printf "%0*d" 2000 0); echo ${#x}'

+

+compare_output "3000-char variable via printf %0*d" \

+  'x=$(printf "%0*d" 3000 0); echo ${#x}'

+

+compare_output "4000-char variable (near limit)" \

+  'x=$(printf "%0*d" 4000 0); echo ${#x}'

+

+compare_output "variable with 1000 'a' chars" \

+  'x=$(printf "a%.0s" $(seq 1 1000)); echo ${#x}'

+

+# printf "a%.0s" with many args hits command expansion buffer

+# use python or head /dev/zero instead for large single-char strings

+compare_output "2000-char variable via head" \

+  'x=$(head -c 2000 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "3000-char variable via head" \

+  'x=$(head -c 3000 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+# BUG: printf "a%.0s" with many args truncates at ~1041 chars (#37)

+compare_output "2000-char via printf repeat" \

+  'x=$(printf "a%.0s" $(seq 1 2000)); echo ${#x}'

+

+compare_output "long variable substring" \

+  'x=$(printf "%0*d" 3000 0); echo ${#x}; y=${x:500:1000}; echo ${#y}'

+

+compare_output "long variable pattern removal" \

+  'x="aaa$(printf "%0*d" 2000 0)aaa"; y=${x##aaa}; echo ${#y}'

+

+# ==========================================

+# 2. Long command lines

+# ==========================================

+section "2 - Long command lines"

+

+compare_output "echo with 500 args" \

+  'echo $(seq 1 500) | wc -w'

+

+compare_output "echo with 1000 args" \

+  'echo $(seq 1 1000) | wc -w'

+

+compare_output "long pipe chain" \

+  'echo hello | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat'

+

+compare_output "long command with semicolons" \

+  'a=1; b=2; c=3; d=4; e=5; f=6; g=7; h=8; i=9; j=10; echo $a $b $c $d $e $f $g $h $i $j'

+

+# ==========================================

+# 3. Array stress tests

+# ==========================================

+section "3 - Array stress tests"

+

+# Use explicit indices to avoid arr[$i]= parsing differences

+compare_output "array direct assignment 10 elements" \

+  'arr=(a b c d e f g h i j); echo ${#arr[@]}'

+

+compare_output "array with explicit long values" \

+  'x=$(printf "%0*d" 100 0); arr[0]=$x; arr[1]=$x; echo ${#arr[0]} ${#arr[1]}'

+

+# BUG: array element assignment truncates long values (#35)

+compare_output "array element from command substitution" \

+  'arr[0]=$(printf "%0*d" 1000 0); echo ${#arr[0]}'

+

+compare_output "array append" \

+  'arr=(); for i in $(seq 1 30); do arr+=("item$i"); done; echo ${#arr[@]}'

+

+compare_output "array slice" \

+  'arr=(a b c d e f g h i j); echo ${arr[@]:3:4}'

+

+compare_output "unset array elements" \

+  'arr=(1 2 3 4 5 6 7 8 9 10); unset arr[4]; unset arr[7]; echo ${#arr[@]}'

+

+# ==========================================

+# 4. Associative array stress tests

+# ==========================================

+section "4 - Associative array stress tests"

+

+compare_output "basic assoc array" \

+  'declare -A m; m[a]=1; m[b]=2; m[c]=3; echo ${#m[@]}'

+

+compare_output "assoc array with long value via var" \

+  'declare -A m; x=$(printf "%0*d" 1000 0); m[k]=$x; echo ${#m[k]}'

+

+# BUG: assoc element assignment truncates long values (#35)

+compare_output "assoc array element from command substitution" \

+  'declare -A m; m[x]=$(printf "%0*d" 1000 0); echo ${#m[x]}'

+

+compare_output "assoc array overwrite" \

+  'declare -A m; m[k]=old; m[k]=new; echo ${m[k]}'

+

+# ==========================================

+# 5. Deep nesting

+# ==========================================

+section "5 - Deep nesting"

+

+compare_output "nested if 10 levels" \

+  'x=1; if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then echo deep; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi'

+

+compare_output "nested loops 5 levels" \

+  'for a in 1 2; do for b in 1 2; do for c in 1 2; do for d in 1 2; do for e in 1 2; do echo "$a$b$c$d$e"; done; done; done; done; done | wc -l'

+

+compare_output "nested command substitution 5 levels" \

+  'echo $(echo $(echo $(echo $(echo hello))))'

+

+compare_output "nested case in loops" \

+  'for i in a b c; do case $i in a) echo A;; b) for j in 1 2; do case $j in 1) echo B1;; 2) echo B2;; esac; done;; c) echo C;; esac; done'

+

+# ==========================================

+# 6. Many variables

+# ==========================================

+section "6 - Many variables"

+

+compare_output "100 variables" \

+  'for i in $(seq 1 100); do eval "var_$i=$i"; done; echo $var_1 $var_50 $var_100'

+

+compare_output "export 50 variables" \

+  'for i in $(seq 1 50); do export "ev_$i=$i"; done; env | grep "^ev_" | wc -l'

+

+compare_output "rapid set/unset cycle" \

+  'for i in $(seq 1 50); do x=$i; unset x; done; echo ${x:-unset}'

+

+# ==========================================

+# 7. Function stress tests

+# ==========================================

+section "7 - Function stress tests"

+

+compare_output "function with many params" \

+  'f() { echo $# $1 $5 ${10}; }; f a b c d e f g h i j'

+

+compare_output "recursive function 10 levels" \

+  'f() { if [ $1 -le 0 ]; then echo done; else f $(($1 - 1)); fi; }; f 10'

+

+compare_output "recursive function 20 levels" \

+  'f() { if [ $1 -le 0 ]; then echo $1; return; fi; f $(($1 - 1)); }; f 20'

+

+# BUG: recursive function 50 levels causes core dump (#36)

+compare_output "recursive function 50 levels" \

+  'f() { if [ $1 -le 0 ]; then echo $1; return; fi; f $(($1 - 1)); }; f 50'

+

+compare_output "function redefine in loop" \

+  'for i in 1 2 3; do eval "f() { echo $i; }"; f; done'

+

+compare_output "function local var scoping" \

+  'f() { local x=inner; echo $x; }; x=outer; f; echo $x'

+

+compare_output "nested function calls 5 levels" \

+  'a() { echo a; b; }; b() { echo b; c; }; c() { echo c; d; }; d() { echo d; e; }; e() { echo e; }; a'

+

+# ==========================================

+# 8. Alias stress tests

+# ==========================================

+section "8 - Alias stress tests"

+

+check_output "alias with long command" \

+  'shopt -s expand_aliases; alias longcmd="echo hello_from_alias"; longcmd' \

+  'hello_from_alias'

+

+compare_output "many aliases" \

+  'shopt -s expand_aliases; for i in $(seq 1 20); do alias "a$i=echo $i"; done; alias | wc -l'

+

+# ==========================================

+# 9. Trap stress tests

+# ==========================================

+section "9 - Trap stress tests"

+

+compare_output "EXIT trap fires" \

+  'trap "echo trapped" EXIT; true'

+

+compare_output "multiple trap signals" \

+  'trap "echo exit" EXIT; trap "echo hup" HUP; trap "echo usr1" USR1; trap -p | grep -cE "(EXIT|HUP|USR1)"'

+

+compare_output "trap set/unset cycle" \

+  'for i in $(seq 1 10); do trap "echo $i" EXIT; done; trap -p EXIT'

+

+# ==========================================

+# 10. Heredoc stress tests

+# ==========================================

+section "10 - Heredoc stress tests"

+

+compare_output "heredoc basic" \

+  'cat <<EOF

+line1

+line2

+line3

+EOF'

+

+compare_output "heredoc with variable expansion" \

+  'x=world; cat <<EOF

+hello $x

+EOF'

+

+compare_output "heredoc with long delimiter" \

+  'cat <<VERYLONGDELIMITERTHATISTOTALLYUNNECESSARY

+hello

+VERYLONGDELIMITERTHATISTOTALLYUNNECESSARY'

+

+# ==========================================

+# 11. String operations on large values

+# ==========================================

+section "11 - String operations"

+

+compare_output "string length of 3000-char var" \

+  'x=$(head -c 3000 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "uppercase transform large string" \

+  'x=$(head -c 1000 /dev/zero | tr "\0" "a"); echo ${x^^} | wc -c'

+

+compare_output "string replacement large string" \

+  'x=$(head -c 1000 /dev/zero | tr "\0" "a"); echo ${x//a/b} | wc -c'

+

+compare_output "concatenation stress" \

+  'x=""; for i in $(seq 1 100); do x="${x}abc"; done; echo ${#x}'

+

+# ==========================================

+# 12. Parameter expansion stress

+# ==========================================

+section "12 - Parameter expansion stress"

+

+compare_output "default value expansion chain" \

+  'echo ${a:-${b:-${c:-${d:-${e:-deep}}}}}'

+

+compare_output "indirect expansion" \

+  'x=hello; ref=x; echo ${!ref}'

+

+compare_output "many positional params" \

+  'set -- $(seq 1 50); echo $# $1 ${25} ${50}'

+

+compare_output "shift through many params" \

+  'set -- $(seq 1 30); shift 15; echo $1 $#'

+

+compare_output "all positional params" \

+  'set -- $(seq 1 20); echo "$@" | wc -w'

+

+# ==========================================

+# 13. Pipeline stress

+# ==========================================

+section "13 - Pipeline stress"

+

+compare_output "10-stage pipeline" \

+  'seq 1 100 | sort -n | head -50 | tail -10 | wc -l'

+

+compare_output "pipeline with large data" \

+  'seq 1 10000 | wc -l'

+

+compare_output "pipeline with grep chain" \

+  'seq 1 1000 | grep 5 | grep -v 50 | wc -l'

+

+# ==========================================

+# 14. Brace expansion stress

+# ==========================================

+section "14 - Brace expansion stress"

+

+compare_output "large sequence" \

+  'echo {1..100} | wc -w'

+

+compare_output "nested braces" \

+  'echo {a,b}{1,2,3}{x,y} | wc -w'

+

+compare_output "alpha sequence" \

+  'echo {a..z} | wc -w'

+

+# ==========================================

+# 15. Boundary conditions

+# ==========================================

+section "15 - Boundary conditions"

+

+compare_output "empty variable operations" \

+  'x=""; echo "${#x}" "${x:-default}" "${x:+set}"'

+

+compare_output "single char variable" \

+  'x=a; echo ${#x} ${x}'

+

+compare_output "null byte handling" \

+  'printf "a\0b" | wc -c'

+

+compare_output "empty command substitution" \

+  'x=$(true); echo "[$x]"'

+

+compare_output "whitespace-only variable" \

+  'x="   "; echo "${#x}" "$x"'

+

+compare_output "long assignment value" \

+  'x=$(head -c 2000 /dev/zero | tr "\0" "z"); echo ${#x}'

+

+compare_output "variable with special chars" \

+  'x="hello'\''world\"test"; echo "$x"'

+

+# ==========================================

+# 16. Pipeline overflow (formerly 4096 ceiling)

+# ==========================================

+section "16 - Pipeline overflow (>4096 byte values)"

+

+compare_output "5000-char variable via head" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "10000-char variable via head" \

+  'x=$(head -c 10000 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "5000-char in echo" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "b"); echo ${#x}'

+

+compare_output "8000-char variable via python" \

+  'x=$(python3 -c "print(\"c\"*8000, end=\"\")"); echo ${#x}'

+

+compare_output "5000-char array assignment via word splitting" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "d"); arr=($x); echo ${#arr[0]}'

+

+compare_output "10000-char array element" \

+  'x=$(head -c 10000 /dev/zero | tr "\0" "e"); arr=($x); echo ${#arr[0]}'

+

+compare_output "multiple 5000-char array elements" \

+  'a=$(head -c 5000 /dev/zero | tr "\0" "f"); b=$(head -c 5000 /dev/zero | tr "\0" "g"); arr=($a $b); echo ${#arr[0]} ${#arr[1]}'

+

+compare_output "5000-char variable string length" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "h"); echo ${#x}'

+

+compare_output "5000-char variable substring" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "i"); y=${x:1000:2000}; echo ${#y}'

+

+compare_output "command substitution preserves 10000 bytes" \

+  'echo $(head -c 10000 /dev/zero | tr "\0" "j") | wc -c'

+

+compare_output "nested command sub with large output" \

+  'x=$(echo $(head -c 5000 /dev/zero | tr "\0" "k")); echo ${#x}'

+

+compare_output "export 5000-char variable" \

+  'export BIGVAR=$(head -c 5000 /dev/zero | tr "\0" "m"); echo ${#BIGVAR}'

+

+# ==========================================

+# 17. Indirect expansion edge cases

+# ==========================================

+section "17 - Indirect expansion edge cases"

+

+compare_output "indirect to unset variable" \

+  'ref=nosuchvar; echo "${!ref}"'

+

+compare_output "indirect with default value" \

+  'x=hello; ref=x; echo ${!ref:-fallback}'

+

+compare_output "indirect chain (not recursive)" \

+  'a=hello; b=a; echo ${!b}'

+

+compare_output "indirect to empty variable" \

+  'x=""; ref=x; echo "[${!ref}]"'

+

+compare_output "indirect to integer variable" \

+  'x=42; ref=x; echo ${!ref}'

+

+compare_output "indirect to PATH" \

+  'ref=PATH; val=${!ref}; echo "${val:0:1}"'

+

+compare_output "indirect with nounset on valid ref" \

+  'set -u; x=hello; ref=x; echo ${!ref}; set +u'

+

+# ==========================================

+# 18. Hardcoded limit boundary tests

+# ==========================================

+section "18 - Hardcoded limit boundaries"

+

+# Case statement patterns (grammar_parser patterns(10) limit)

+# NOTE: increasing case limits causes stack frame overflow in nested parsing.

+# Keeping limits at patterns(10)/items(20) to avoid stack corruption.

+# Issue tracked for future heap-allocation refactor.

+compare_output "case with 9 patterns" \

+  'x=9; case $x in 1) echo a;; 2) echo b;; 3) echo c;; 4) echo d;; 5) echo e;; 6) echo f;; 7) echo g;; 8) echo h;; 9) echo i;; esac'

+

+compare_output "case with 10 patterns" \

+  'x=10; case $x in 1) echo a;; 2) echo b;; 3) echo c;; 4) echo d;; 5) echo e;; 6) echo f;; 7) echo g;; 8) echo h;; 9) echo i;; 10) echo j;; esac'

+

+compare_output "case with 18 items" \

+  'x=18; case $x in 1) echo a;; 2) echo b;; 3) echo c;; 4) echo d;; 5) echo e;; 6) echo f;; 7) echo g;; 8) echo h;; 9) echo i;; 10) echo j;; 11) echo k;; 12) echo l;; 13) echo m;; 14) echo n;; 15) echo o;; 16) echo p;; 17) echo q;; 18) echo r;; esac'

+

+# Many function definitions (function_ast_cache(20) limit)

+compare_output "25 function definitions" \

+  'for i in $(seq 1 25); do eval "f_$i() { echo $i; }"; done; f_1; f_13; f_25'

+

+compare_output "30 function definitions" \

+  'for i in $(seq 1 30); do eval "f_$i() { echo $i; }"; done; f_1; f_15; f_30'

+

+# Many prefix assignments (saved_var_names(10) limit)

+compare_output "5 prefix assignments" \

+  'A=1 B=2 C=3 D=4 E=5 env | grep -c "^[ABCDE]="'

+

+compare_output "12 prefix assignments" \

+  'A=1 B=2 C=3 D=4 E=5 F=6 G=7 H=8 I=9 J=10 K=11 L=12 env | grep -c "^[A-L]="'

+

+# Many shell variables (MAX_SHELL_VARS=512)

+compare_output "200 variables" \

+  'for i in $(seq 1 200); do eval "var_$i=$i"; done; echo $var_1 $var_100 $var_200'

+

+compare_output "400 variables" \

+  'i=1; while [ $i -le 400 ]; do eval "var_$i=$i"; i=$((i+1)); done; echo $var_1 $var_200 $var_400'

+

+# Control flow nesting depth (MAX_CONTROL_DEPTH=20)

+compare_output "nested if 15 levels" \

+  'x=1; if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then if [ $x -eq 1 ]; then echo deep15; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi; fi'

+

+# Long variable names (MAX_VAR_NAME_LEN=256)

+compare_output "100-char variable name" \

+  'eval "$(printf "a%.0s" $(seq 1 100))=hello"; eval "echo \$$(printf "a%.0s" $(seq 1 100))"'

+

+compare_output "200-char variable name" \

+  'eval "$(printf "a%.0s" $(seq 1 200))=world"; eval "echo \$$(printf "a%.0s" $(seq 1 200))"'

+

+# ==========================================

+# 19. Recursion & stack pressure

+# ==========================================

+section "19 - Recursion and stack pressure"

+

+compare_output "recursive function 75 levels" \

+  'f() { if [ $1 -le 0 ]; then echo $1; return; fi; f $(($1 - 1)); }; f 75'

+

+compare_output "recursive function 100 levels" \

+  'f() { if [ $1 -le 0 ]; then echo $1; return; fi; f $(($1 - 1)); }; f 100'

+

+compare_output "mutual recursion 20 levels" \

+  'a() { if [ $1 -le 0 ]; then echo done; return; fi; b $(($1-1)); }; b() { a "$1"; }; a 20'

+

+compare_output "nested subshells 10 levels" \

+  '(echo 1; (echo 2; (echo 3; (echo 4; (echo 5; (echo 6; (echo 7; (echo 8; (echo 9; (echo 10))))))))))'

+

+compare_output "nested command substitution 10 levels" \

+  'echo $(echo $(echo $(echo $(echo $(echo $(echo $(echo $(echo $(echo hello)))))))))'

+

+compare_output "nested arithmetic 20 levels" \

+  'echo $(( ((((((((((((((((((((1+1)))))))))))))))))))) ))'

+

+# ==========================================

+# 20. Memory & buffer boundary tests

+# ==========================================

+section "20 - Buffer boundaries"

+

+# Command substitution at exact power-of-2 boundaries

+compare_output "cmd sub exactly 4096 bytes" \

+  'x=$(head -c 4096 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "cmd sub exactly 4097 bytes" \

+  'x=$(head -c 4097 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "cmd sub exactly 8192 bytes" \

+  'x=$(head -c 8192 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "cmd sub exactly 8193 bytes" \

+  'x=$(head -c 8193 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "cmd sub exactly 16384 bytes" \

+  'x=$(head -c 16384 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+compare_output "cmd sub exactly 65536 bytes" \

+  'x=$(head -c 65536 /dev/zero | tr "\0" "a"); echo ${#x}'

+

+# Pattern matching on large strings

+compare_output "pattern removal on 5000-char string" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "a"); y=${x#aaa}; echo ${#y}'

+

+compare_output "pattern replace on 5000-char string" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "a"); echo ${x//a/b} | wc -c'

+

+# Sparse array

+compare_output "sparse array index 10000" \

+  'arr[10000]=hello; echo ${arr[10000]}'

+

+compare_output "sparse array index 99999" \

+  'arr[99999]=world; echo ${arr[99999]}'

+

+# Arithmetic integer boundaries

+compare_output "arithmetic max int" \

+  'echo $((9223372036854775807))'

+

+compare_output "arithmetic large multiplication" \

+  'echo $((1000000 * 1000000))'

+

+compare_output "arithmetic negative" \

+  'echo $((-2147483648))'

+

+# Substring at boundary offsets

+compare_output "substring negative offset" \

+  'x=hello_world; echo ${x: -5}'

+

+compare_output "substring offset beyond length" \

+  'x=hi; echo "[${x:100:5}]"'

+

+compare_output "substring zero length" \

+  'x=hello; echo "[${x:2:0}]"'

+

+# ==========================================

+# 21. Tokenization limits

+# ==========================================

+section "21 - Tokenization limits"

+

+compare_output "echo with 200 arguments" \

+  'echo $(seq 1 200) | wc -w'

+

+compare_output "echo with 400 arguments" \

+  'echo $(seq 1 400) | wc -w'

+

+compare_output "many semicolons 30 commands" \

+  'a=0; a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); a=$((a+1)); echo $a'

+

+# ==========================================

+# 22. FD & redirection stress

+# ==========================================

+section "22 - FD and redirection stress"

+

+compare_output "rapid redirect cycling 100 iterations" \

+  'i=1; while [ $i -le 100 ]; do echo $i > /tmp/fortsh_test_fd_$$; i=$((i+1)); done; cat /tmp/fortsh_test_fd_$$; rm -f /tmp/fortsh_test_fd_$$'

+

+compare_output "append redirect 200 lines" \

+  'rm -f /tmp/fortsh_test_append_$$; i=1; while [ $i -le 200 ]; do echo $i >> /tmp/fortsh_test_append_$$; i=$((i+1)); done; wc -l < /tmp/fortsh_test_append_$$; rm -f /tmp/fortsh_test_append_$$'

+

+compare_output "stderr redirect in loop" \

+  'for i in 1 2 3 4 5; do echo "err$i" >&2; done 2>&1 | wc -l'

+

+compare_output "output and error merge" \

+  '{ echo stdout; echo stderr >&2; } 2>&1 | sort'

+

+compare_output "dev null redirect in loop" \

+  'i=1; while [ $i -le 100 ]; do echo $i > /dev/null; i=$((i+1)); done; echo done'

+

+# ==========================================

+# 23. Pipeline & fork stress

+# ==========================================

+section "23 - Pipeline and fork stress"

+

+compare_output "15-stage pipeline" \

+  'echo hello | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat'

+

+compare_output "20-stage pipeline" \

+  'echo hello | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat | cat'

+

+compare_output "pipeline with 100000 lines" \

+  'seq 1 100000 | wc -l'

+

+compare_output "pipeline with sort 10000 lines" \

+  'seq 1 10000 | sort -rn 2>/dev/null | head -1'

+

+compare_output "background job wait cycling" \

+  'i=1; while [ $i -le 50 ]; do true & i=$((i+1)); done; wait; echo done'

+

+compare_output "100 background jobs then wait" \

+  'i=1; while [ $i -le 100 ]; do true & i=$((i+1)); done; wait; echo done'

+

+compare_output "subshell pipeline isolation" \

+  'x=outer; echo $x | (read y; echo $y) | cat'

+

+# ==========================================

+# 24. Array scaling

+# ==========================================

+section "24 - Array scaling"

+

+# BUG: arr[$i]=$i doesn't expand $i in subscript — use eval workaround

+compare_output "indexed array 100 elements" \

+  'i=0; while [ $i -lt 100 ]; do eval "arr[$i]=$i"; i=$((i+1)); done; echo ${#arr[@]} ${arr[0]} ${arr[50]} ${arr[99]}'

+

+compare_output "indexed array 500 elements" \

+  'i=0; while [ $i -lt 500 ]; do eval "arr[$i]=$i"; i=$((i+1)); done; echo ${#arr[@]} ${arr[0]} ${arr[250]} ${arr[499]}'

+

+# BUG: arr=($(cmd)) doesn't word-split command substitution into elements

+compare_output "indexed array via init list 20" \

+  'arr=(a b c d e f g h i j k l m n o p q r s t); echo ${#arr[@]} ${arr[0]} ${arr[19]}'

+

+compare_output "array append 500 times" \

+  'arr=(); i=0; while [ $i -lt 500 ]; do arr+=("$i"); i=$((i+1)); done; echo ${#arr[@]}'

+

+# BUG: m["key$i"] doesn't expand $i in subscript — use eval workaround

+compare_output "assoc array 100 keys" \

+  'declare -A m; i=1; while [ $i -le 100 ]; do eval "m[key$i]=$i"; i=$((i+1)); done; echo ${#m[@]} ${m[key1]} ${m[key50]} ${m[key100]}'

+

+compare_output "assoc array 200 keys" \

+  'declare -A m; i=1; while [ $i -le 200 ]; do eval "m[key$i]=$i"; i=$((i+1)); done; echo ${#m[@]}'

+

+compare_output "assoc array overwrite cycle" \

+  'declare -A m; i=1; while [ $i -le 100 ]; do m[k]=$i; i=$((i+1)); done; echo ${m[k]}'

+

+compare_output "array element 10000-char value" \

+  'x=$(head -c 10000 /dev/zero | tr "\0" "a"); arr[0]=$x; echo ${#arr[0]}'

+

+# ==========================================

+# 25. Control flow edge cases

+# ==========================================

+section "25 - Control flow edge cases"

+

+compare_output "mixed loop nesting for-while-until" \

+  'for i in 1 2; do j=0; while [ $j -lt 2 ]; do k=5; until [ $k -le 3 ]; do k=$((k-1)); done; echo "$i $j $k"; j=$((j+1)); done; done'

+

+compare_output "break 2 from inner loop" \

+  '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; echo end'

+

+compare_output "break 3 from triple nested" \

+  'for i in 1 2; do for j in a b; do for k in x y; do if [ "$k" = "y" ]; then break 3; fi; echo "$i$j$k"; done; done; done; echo end'

+

+compare_output "continue 2 from inner loop" \

+  'for i in 1 2 3; do for j in a b c; do if [ "$j" = "b" ]; then continue 2; fi; echo "$i$j"; done; done'

+

+compare_output "loop 5000 iterations" \

+  'x=0; i=0; while [ $i -lt 5000 ]; do x=$((x+1)); i=$((i+1)); done; echo $x'

+

+# 10000 iterations takes ~72s on ARM64, ~1s on x86_64

+case "$(uname -m)" in

+  arm64|aarch64) TEST_TIMEOUT=180 ;;

+  *)             TEST_TIMEOUT=60 ;;

+esac

+compare_output "loop 10000 iterations" \

+  'x=0; i=0; while [ $i -lt 10000 ]; do x=$((x+1)); i=$((i+1)); done; echo $x'

+case "$(uname -m)" in

+  arm64|aarch64) TEST_TIMEOUT=90 ;;

+  *)             TEST_TIMEOUT=30 ;;

+esac

+

+compare_output "while with complex condition" \

+  'i=0; while [ $i -lt 10 ] && [ $((i % 2)) -eq 0 -o $i -lt 5 ]; do echo $i; i=$((i+1)); done'

+

+compare_output "nested case in loop" \

+  'for i in $(seq 1 20); do case $((i % 4)) in 0) echo "a$i";; 1) echo "b$i";; 2) echo "c$i";; 3) echo "d$i";; esac; done | wc -l'

+

+# ==========================================

+# 26. Trap & signal stress

+# ==========================================

+section "26 - Trap and signal stress"

+

+compare_output "set traps on 10 signals" \

+  'trap "echo 1" HUP; trap "echo 2" INT; trap "echo 3" QUIT; trap "echo 4" TERM; trap "echo 5" USR1; trap "echo 6" USR2; trap "echo 7" PIPE; trap "echo 8" ALRM; trap "echo 9" CONT; trap "echo exit" EXIT; trap -p | wc -l'

+

+compare_output "trap reset cycling 50 times" \

+  'i=1; while [ $i -le 50 ]; do trap "echo $i" EXIT; i=$((i+1)); done; trap -p EXIT'

+

+compare_output "trap with long handler" \

+  'handler=""; i=1; while [ $i -le 100 ]; do handler="${handler}echo $i;"; i=$((i+1)); done; trap "$handler" EXIT; echo before'

+

+compare_output "modify trap inside trap" \

+  'trap '\''trap "echo inner" EXIT; echo outer'\'' EXIT; exit 0'

+

+compare_output "trap unset then reset" \

+  'trap "echo first" EXIT; trap - EXIT; trap "echo second" EXIT; exit 0'

+

+# ==========================================

+# 27. String & expansion stress

+# ==========================================

+section "27 - String and expansion stress"

+

+compare_output "uppercase 5000-char variable" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "a"); echo ${x^^} | wc -c'

+

+compare_output "lowercase 5000-char variable" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "A"); echo ${x,,} | wc -c'

+

+compare_output "global replace 5000-char variable" \

+  'x=$(head -c 5000 /dev/zero | tr "\0" "a"); echo ${x//a/b} | wc -c'

+

+compare_output "concatenation loop 5000 chars" \

+  'x=""; for i in $(seq 1 1000); do x="${x}abcde"; done; echo ${#x}'

+

+compare_output "prefix removal on 10000-char string" \

+  'x=$(head -c 10000 /dev/zero | tr "\0" "a"); y=${x#aaaa}; echo ${#y}'

+

+compare_output "suffix removal on 10000-char string" \

+  'x=$(head -c 10000 /dev/zero | tr "\0" "a"); y=${x%aaaa}; echo ${#y}'

+

+compare_output "default expansion chain 8 deep" \

+  'echo ${a:-${b:-${c:-${d:-${e:-${f:-${g:-${h:-deep8}}}}}}}}'

+

+compare_output "assign-default expansion" \

+  'unset x; echo ${x:=hello}; echo $x'

+

+compare_output "error-if-unset expansion" \

+  'x=set; echo ${x:?should not error}'

+

+# ==========================================

+# 28. Heredoc scaling

+# ==========================================

+section "28 - Heredoc scaling"

+

+compare_output "heredoc 50 lines" \

+  'cat <<EOF | wc -l

+$(seq 1 50)

+EOF'

+

+compare_output "heredoc with 20 variable expansions" \

+  'a=1; b=2; c=3; d=4; e=5; f=6; g=7; h=8; i=9; j=10; cat <<EOF

+$a $b $c $d $e $f $g $h $i $j $a $b $c $d $e $f $g $h $i $j

+EOF'

+

+compare_output "heredoc with command substitution" \

+  'cat <<EOF