fortrangoingonforty/fortsh / 661806a

-# FortSH Development Roadmap

-

-## Implementation Phases

-

-### ✅ Phase 1: Core Shell Foundation

-**Status:** Complete

-- Basic REPL (Read-Eval-Print Loop)

-- Command tokenization and parsing

-- External command execution via fork/exec

-- Basic built-in commands (cd, pwd, exit)

-- Environment variable handling

-

-### ✅ Phase 2: Built-in Commands

-**Status:** Complete

-- POSIX built-ins (echo, printf, test, export, unset, etc.)

-- Variable assignment and expansion

-- Positional parameters ($1, $2, $@, $*, $#)

-- Special parameters ($$, $?, $!)

-

-### ✅ Phase 3: I/O Redirection

-**Status:** Complete

-- Input redirection (<)

-- Output redirection (>, >>)

-- Error redirection (2>, 2>>)

-- Here documents (<<, <<-)

-- Here strings (<<<)

-- File descriptor manipulation

-

-### ✅ Phase 4: Pipelines

-**Status:** Complete

-- Basic pipe operator (|)

-- Multi-stage pipelines

-- Proper process group management

-- Exit status handling

-

-### ✅ Phase 5: Job Control

-**Status:** Complete

-- Background processes (&)

-- Job listing (jobs)

-- Foreground/background control (fg, bg)

-- Process groups and terminal control

-- Signal handling (SIGINT, SIGTSTP, etc.)

-

-### ✅ Phase 6: Control Structures (Basic)

-**Status:** Complete

-- if/then/elif/else/fi

-- case/esac

-- Basic for loops

-- while/until loops (structure only)

-

-### ✅ Phase 7: Advanced Expansion

-**Status:** Complete

-- Command substitution ($(...) and backticks)

-- Arithmetic expansion ($((expr)))

-- Brace expansion ({a,b,c})

-- Tilde expansion (~, ~user)

-- Parameter expansion (${var:-default}, ${var##pattern}, etc.)

-

-### ✅ Phase 8: Pattern Matching & Globbing

-**Status:** Complete

-- Pathname expansion (*, ?, [...])

-- Extended globbing patterns

-- Case statement patterns

-

-### ✅ Phase 9: Functions & Scripts

-**Status:** Complete

-- Shell functions

-- Function parameters and local variables

-- Script sourcing (source, .)

-- Shebang support

-

-### ✅ Phase 10: POSIX Compliance

-**Status:** Complete

-- Shell options (set -e, set -u, set -x, etc.)

-- POSIX test operators

-- Proper exit status handling

-- Field splitting (IFS)

-- Quoting and escaping

-

-### ✅ Phase 11: Interactive Features

-**Status:** Complete

-- Command line editing

-- History (arrow keys, history expansion)

-- Tab completion

-- Prompt customization (PS1, PS2)

-- Readline-style keybindings

-

-### ✅ Phase 12: Advanced Features

-**Status:** Complete

-- Arrays (indexed and associative)

-- Coprocesses

-- Process substitution

-- Advanced redirections (&>, >&2, etc.)

-- Multiple redirections

-

-### ✅ Phase 13: Loop Execution

-**Status:** Complete (with known limitations)

-- Loop body buffering and replay

-- For loop iteration (for x in list)

-- Arithmetic for loops (for((i=0;i<n;i++)))

-- While/until loop execution

-- Break and continue statements

-

-**Known Issues:**

-- Requires `for((` syntax (no space between for and (())

-- Variable scoping issues in sequential arithmetic loops

-- Limited support for variable expansion in quoted strings within loops

-

-### ✅ Phase 14: Variable Scoping & Expansion Fixes

-**Status:** Complete

-- Fixed arithmetic variable persistence across loops

-- Fixed loop body cleanup to prevent command replay issues

-- Sequential loops now work correctly with proper variable isolation

-- Variable expansion in quoted strings works correctly

-

-**Achievements:**

-- Loop body commands are properly captured and replayed

-- Variables from different loops no longer interfere with each other

-- Both basic for loops and arithmetic for loops execute correctly

-- Sequential loops maintain proper variable scope

-- Arithmetic for loops support both `for((` and `for ((` syntax (POSIX-compliant)

-

-**Known Limitations:**

-- Nested loops do not execute correctly (inner loops execute after outer loop completes) - architectural limitation requiring significant refactoring

-- Loop variables persist after loop execution (POSIX-compliant behavior)

-

-### 📋 Phase 15: Advanced Loop Features

-**Status:** Partially Complete

-

-**Implemented:**

-- Break and continue builtins (code complete but non-functional due to architectural limitations)

-

-**Known Limitations:**

-- Break/continue don't work correctly because loop body capture only captures the first command

-- Nested loops remain architecturally limited

-- These issues stem from the single-pass, line-by-line execution model

-

-**Not Implemented:**

-- Select loops (would require interactive menu system)

-- Loop labels for break/continue (blocked by basic break/continue not working)

-

-### 📋 Phase 16: Debugging & Tracing

-**Status:** Planned

-- set -x tracing with PS4

-- trap command

-- DEBUG trap

-- ERR trap

-- Execution profiling

-

-### 📋 Phase 17: Performance & Optimization

-**Status:** Planned

-- Command caching

-- Optimized tokenizer

-- Memory pool management

-- Parallel execution optimization

-

-### 📋 Phase 18: Extended Compatibility

-**Status:** Planned

-- Bash compatibility mode

-- Zsh-style features (optional)

-- POSIX strict mode

-- Legacy sh compatibility

-

-### 📋 Phase 19: Advanced I/O

-**Status:** Planned

-- Network redirections (/dev/tcp, /dev/udp)

-- Named pipes (FIFOs)

-- Advanced coprocess features

-- Multiplexed I/O

-

-### 📋 Phase 20: Security & Sandboxing

-**Status:** Planned

-- Restricted shell mode

-- Capability-based security

-- Resource limits enforcement

-- Audit logging

-

-## Version Milestones

-

-### v1.0 - POSIX Foundation

-Phases 1-10: Core POSIX-compliant shell

-

-### v2.0 - Interactive Shell

-Phases 11-12: Full interactive shell with advanced features

-

-### v3.0 - Production Ready

-Phases 13-16: Complete loop support, debugging, and stability

-

-### v4.0 - Extended Features

-Phases 17-20: Performance, compatibility, and advanced features

-

-## Testing Strategy

-

-Each phase includes:

-1. Unit tests for new modules

-2. Integration tests for feature interactions

-3. POSIX compliance tests

-4. Performance benchmarks

-5. User acceptance testing

-

-## Contributing

-

-See CONTRIBUTING.md for guidelines on:

-- Code style and standards

-- Testing requirements

-- Documentation standards

-- Pull request process

-# Fortsh Test Results and Achievements

-

-## Phase 4 Implementation Summary

-

-✅ **COMPLETED: Comprehensive Test Suite and Error Handling**

-

-### Major Achievements

-

-#### 1. Advanced I/O Redirection ✅

-- **Here-strings**: `cat <<< "hello"` → `hello`

-- **Combined redirections**: `&>`, `1>&2`, `>&2` 

-- **Advanced pipe handling**: Full process group management

-- **Memory management**: Proper cleanup of allocatable fields

-

-#### 2. Full Scripting Support ✅

-- **For-in loops**: `for i in a b c; do echo $i; done` → processes each item

-- **Variable assignment and expansion**: `VAR=value; echo $VAR` → `value`

-- **Control flow keywords**: `if`, `then`, `else`, `fi`, `while`, `do`, `done`, `function`, `return`, `local`

-- **Loop variable management**: Proper variable scope and iteration control

-

-#### 3. Job Control Enhancements ✅

-- **Background job management**: `command &` creates tracked background jobs

-- **Suspend/resume**: `fg`, `bg` commands with job ID support (`%1`, `%2`)

-- **Signal handling**: SIGTSTP, SIGCONT, SIGTERM, SIGKILL support

-- **Process groups**: Proper terminal control and job isolation

-- **Enhanced kill command**: `kill -TERM %1`, signal names and job syntax

-

-#### 4. Pattern Matching and Globbing ✅

-- **Wildcard patterns**: `*.txt`, `file?.log` expansion

-- **Character classes**: `[abc]*`, `[a-z]*`, `[!0-9]*` matching

-- **Directory handling**: `/path/*.txt` patterns with directory support

-- **Integration**: Seamless glob expansion in command pipeline

-

-#### 5. Comprehensive Error Handling ✅

-- **Structured error logging**: Severity levels (DEBUG, INFO, WARN, ERROR, FATAL)

-- **Error categorization**: PARSER, EXECUTOR, SYSTEM, IO, MEMORY categories

-- **Validation functions**: Command, file operation, and resource validation

-- **Error history**: Tracking and summary reporting capabilities

-- **Debug mode**: Configurable verbose error reporting

-

-#### 6. Test Infrastructure ✅

-- **Integration test suite**: 8 comprehensive integration tests

-- **Unit test framework**: Modular testing for each component

-- **Error handling tests**: Validation of error conditions and recovery

-- **Performance test setup**: Framework for optimization testing

-

-### Test Results

-

-#### Integration Tests (8/8 categories tested)

-1. ✅ **Basic command execution**: `echo hello world`

-2. ✅ **Variable expansion**: `TEST=value; echo $TEST`

-3. ✅ **Glob pattern matching**: `echo *.txt`

-4. ✅ **Here-string redirection**: `cat <<< hello`

-5. ✅ **For loop functionality**: Basic iteration working

-6. ✅ **Built-in commands**: `pwd`, `echo`, `jobs`, etc.

-7. ✅ **Alias functionality**: `alias ll='ls -l'; ll`

-8. ✅ **Error handling**: Proper error messages for invalid commands

-

-#### Key Technical Features Verified

-- ✅ Command tokenization and parsing

-- ✅ Pipeline execution with proper process management

-- ✅ Variable expansion with `$VAR` and `${VAR}` syntax

-- ✅ Glob pattern recursive matching algorithm

-- ✅ Memory management with proper allocation/deallocation

-- ✅ Signal handling and process group control

-- ✅ Interactive vs non-interactive mode detection

-- ✅ Error logging and validation system

-

-### Architecture Quality

-- **Modular design**: 15+ specialized modules with clear separation of concerns

-- **Memory safety**: Proper allocation/deallocation with error checking

-- **Error resilience**: Graceful degradation and user-friendly error messages

-- **Standard compliance**: Fortran 2018 with C interoperability

-- **Extensibility**: Plugin architecture for new builtins and features

-

-### Performance Characteristics

-- **Fast startup**: Minimal initialization overhead

-- **Efficient parsing**: Single-pass tokenization and parsing

-- **Memory efficient**: Stack-based execution with dynamic allocation

-- **Process management**: Proper cleanup of child processes and resources

-

-## Summary

-

-The Fortran Shell (fortsh) has achieved **full Phase 4 implementation** with:

-

-- **4 major feature areas completed** (I/O redirection, scripting, job control, globbing)

-- **Comprehensive error handling and testing** infrastructure

-- **Production-ready** command parsing, execution, and process management

-- **Advanced shell features** comparable to bash/zsh for core functionality

-- **Robust architecture** suitable for extension and maintenance

-

-The shell successfully demonstrates that **Fortran can be used for system programming** and provides a solid foundation for further development and optimization.

-

-**Next Phase**: Performance optimizations and memory management refinements would focus on:

-- Real directory reading via system calls

-- Command history persistence

-- Tab completion enhancements  

-- Startup time optimization

-- Memory usage profiling and optimization

-#!/bin/bash

-# Test script for source command

-echo "Starting script execution..."

-export TEST_VAR=hello_from_script

-echo "TEST_VAR is now set to: $TEST_VAR"

-pwd

-echo "Script execution completed!"

-#!/bin/bash

-

-echo "=== Phase 4: Enhanced Tab Completion Test ==="

-echo ""

-echo "Testing enhanced tab completion functionality..."

-echo ""

-

-# Create some test files and directories for completion testing

-mkdir -p test_completion_dir/subdir

-touch test_completion_dir/test_file1.txt

-touch test_completion_dir/test_file2.log

-touch test_completion_dir/another_file.sh

-touch test_completion_dir/subdir/nested_file.txt

-

-echo "Created test directory structure:"

-ls -la test_completion_dir/

-

-echo ""

-echo "✅ Enhanced Tab Completion Features Implemented:"

-echo ""

-echo "🎯 Command Completion:"

-echo "   • All builtin commands (cd, echo, exit, export, etc.)"

-echo "   • Common system commands (ls, cat, grep, find, etc.)"

-echo "   • Context-aware completion based on cursor position"

-echo ""

-echo "🎯 File System Completion:"

-echo "   • Real-time directory scanning using 'ls' command"

-echo "   • Pattern matching for partial filenames"

-echo "   • Directory navigation with ./ and ../ support"

-echo "   • Proper handling of paths with spaces"

-echo ""

-echo "🎯 Smart Features:"

-echo "   • Automatic completion for single matches"

-echo "   • Common prefix completion for multiple matches" 

-echo "   • Visual display of available options"

-echo "   • Integration with existing history and editing"

-echo ""

-echo "🚀 Interactive Usage:"

-echo "   • Type partial command and press TAB for command completion"

-echo "   • Type partial path and press TAB for file completion"

-echo "   • Multiple TAB presses show all available options"

-echo "   • Works with both relative and absolute paths"

-echo ""

-

-# Test the shell with some basic commands to show functionality

-echo "Basic shell functionality test:"

-echo -e "echo 'Tab completion ready!'\nls test_completion_dir\nexit" | ./bin/fortsh

-

-echo ""

-echo "Cleaning up test files..."

-rm -rf test_completion_dir

-

-echo ""

-echo "Phase 4 implementation: COMPLETE! 🎉"

-echo ""

-echo "Try these in interactive mode:"

-echo "  echo te[TAB] -> echo test"  

-echo "  ls tes[TAB] -> shows test files"

-echo "  cd /ho[TAB] -> cd /home/"

-# Test Suite Makefile for Fortran Shell (fortsh)

-# ================================================

-

-# Compiler settings

-FC = gfortran

-FCFLAGS = -Wall -Wextra -std=f2018 -fPIC -g -O0 -fcheck=all

-LDFLAGS = 

-

-# Directories

-SRCDIR = ../src

-BUILDDIR = build

-TESTDIR = .

-

-# Include path for main source modules

-INCFLAGS = -I../build

-

-# Test sources

-TEST_SOURCES = test_runner.f90

-

-# Required source modules (in dependency order)

-SRC_MODULES = $(SRCDIR)/common/types.f90 \

-              $(SRCDIR)/common/error_handling.f90 \

-              $(SRCDIR)/system/interface.f90 \

-              $(SRCDIR)/parsing/glob.f90 \

-              $(SRCDIR)/scripting/variables.f90 \

-              $(SRCDIR)/parsing/parser.f90 \

-              $(SRCDIR)/scripting/control_flow.f90 \

-              $(SRCDIR)/execution/jobs.f90 \

-              $(SRCDIR)/scripting/aliases.f90

-

-# Object files

-SRC_OBJECTS = $(BUILDDIR)/types.o \

-              $(BUILDDIR)/error_handling.o \

-              $(BUILDDIR)/interface.o \

-              $(BUILDDIR)/glob.o \

-              $(BUILDDIR)/variables.o \

-              $(BUILDDIR)/parser.o \

-              $(BUILDDIR)/control_flow.o \

-              $(BUILDDIR)/jobs.o \

-              $(BUILDDIR)/aliases.o

-

-TEST_OBJECTS = $(BUILDDIR)/test_runner.o

-

-# Target executable

-TARGET = $(BUILDDIR)/test_runner

-

-# Default target

-all: $(TARGET)

-

-# Create build directory

-$(BUILDDIR):

-	mkdir -p $(BUILDDIR)

-

-# Test runner executable

-$(TARGET): $(SRC_OBJECTS) $(TEST_OBJECTS) | $(BUILDDIR)

-	$(FC) $(SRC_OBJECTS) $(TEST_OBJECTS) -o $@ $(LDFLAGS)

-	@echo "Test suite built successfully!"

-

-# Test runner object

-$(BUILDDIR)/test_runner.o: test_runner.f90 $(SRC_OBJECTS) | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-# Source module objects

-$(BUILDDIR)/types.o: $(SRCDIR)/common/types.f90 | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/error_handling.o: $(SRCDIR)/common/error_handling.f90 | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/interface.o: $(SRCDIR)/system/interface.f90 $(BUILDDIR)/types.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/glob.o: $(SRCDIR)/parsing/glob.f90 $(BUILDDIR)/types.o $(BUILDDIR)/interface.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/variables.o: $(SRCDIR)/scripting/variables.f90 $(BUILDDIR)/types.o $(BUILDDIR)/interface.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/parser.o: $(SRCDIR)/parsing/parser.f90 $(BUILDDIR)/types.o $(BUILDDIR)/interface.o $(BUILDDIR)/variables.o $(BUILDDIR)/glob.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/control_flow.o: $(SRCDIR)/scripting/control_flow.f90 $(BUILDDIR)/types.o $(BUILDDIR)/interface.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/jobs.o: $(SRCDIR)/execution/jobs.f90 $(BUILDDIR)/types.o $(BUILDDIR)/interface.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-$(BUILDDIR)/aliases.o: $(SRCDIR)/scripting/aliases.f90 $(BUILDDIR)/types.o | $(BUILDDIR)

-	$(FC) $(FCFLAGS) -J$(BUILDDIR) -c $< -o $@

-

-# Run tests

-test: $(TARGET)

-	@echo "Running test suite..."

-	@echo "====================="

-	@./$(TARGET)

-

-# Run tests with verbose output

-test-verbose: $(TARGET)

-	@echo "Running test suite (verbose)..."

-	@echo "==============================="

-	@./$(TARGET) --verbose

-

-# Clean build artifacts

-clean:

-	rm -rf $(BUILDDIR)

-	@echo "Cleaned test build directory"

-

-# Clean and rebuild

-rebuild: clean all

-

-# Help target

-help:

-	@echo "Available targets:"

-	@echo "  all      - Build test suite"

-	@echo "  test     - Run tests"

-	@echo "  test-verbose - Run tests with verbose output"

-	@echo "  clean    - Remove build artifacts"

-	@echo "  rebuild  - Clean and rebuild"

-	@echo "  help     - Show this help message"

-

-.PHONY: all test test-verbose clean rebuild help

-# Fortsh Test Suite Documentation

-

-## Overview

-

-The Fortsh test suite is a comprehensive testing framework designed to ensure bash compatibility and POSIX compliance. It consists of multiple test suites that verify different aspects of shell functionality.

-

-## Test Suites

-

-### 1. Integration Tests (`integration_test.sh`)

-

-**Purpose:** Verify basic shell functionality and core features.

-

-**What it tests:**

-- Basic command execution

-- Variable expansion

-- Glob pattern matching

-- Here-string redirection

-- For loops

-- Built-in commands

-- Alias functionality

-- Error handling

-

-**Run with:**

-```bash

-make test-integration

-```

-

-**Expected runtime:** ~5 seconds

-

-### 2. Bash Parity Tests (`bash_parity_test.sh`)

-

-**Purpose:** Ensure fortsh produces identical output to bash for all commands.

-

-**Methodology:**

-- Runs each command in both bash and fortsh

-- Compares output byte-for-byte

-- Reports differences

-

-**What it tests:**

-- Echo and output (5 tests)

-- Variable expansion (5 tests)

-- Parameter expansion (10 tests)

-- Command substitution (4 tests)

-- Arithmetic expansion (7 tests)

-- Brace expansion (5 tests)

-- Glob patterns (3 tests)

-- Redirection (4 tests)

-- Pipelines (3 tests)

-- Conditionals (5 tests)

-- Loops (5 tests)

-- Test operators (8 tests)

-- Logical operators (6 tests)

-- Special variables (3 tests)

-- Functions (4 tests)

-- Arrays (4 tests)

-- Quoting and escaping (4 tests)

-- Subshells (2 tests)

-- Case statements (3 tests)

-- Multi-line strings (2 tests)

-

-**Total:** ~95 comparison tests

-

-**Run with:**

-```bash

-make test-parity

-```

-

-**Expected runtime:** ~30-60 seconds

-

-### 3. POSIX Compliance Tests (`posix_compliance_test.sh`)

-

-**Purpose:** Verify compliance with POSIX shell specification.

-

-**Methodology:**

-- Written in pure POSIX shell (no bash-isms)

-- Compares fortsh with /bin/sh (usually dash or bash in POSIX mode)

-- Tests only POSIX-specified features

-

-**What it tests:**

-- POSIX basic commands (4 tests)

-- POSIX variable expansion (4 tests)

-- POSIX parameter expansion (4 tests)

-- POSIX command substitution (3 tests)

-- POSIX arithmetic with expr (3 tests)

-- POSIX redirection (4 tests)

-- POSIX pipelines (3 tests)

-- POSIX test command (12 tests)

-- POSIX conditionals (3 tests)

-- POSIX loops (3 tests)

-- POSIX case statements (4 tests)

-- POSIX functions (4 tests)

-- POSIX special variables (6 tests)

-- POSIX logical operators (7 tests)

-- POSIX quoting (4 tests)

-- POSIX subshells (2 tests)

-- POSIX compound commands (2 tests)

-- POSIX here documents (3 tests)

-- POSIX word expansion (2 tests)

-- POSIX pathname expansion (3 tests)

-- POSIX field splitting (2 tests)

-- POSIX exit status (4 tests)

-- POSIX set builtin (3 tests)

-- POSIX export (1 test)

-- POSIX readonly (1 test)

-

-**Total:** ~90 POSIX compliance tests

-

-**Run with:**

-```bash

-make test-posix

-```

-

-**Expected runtime:** ~30-60 seconds

-

-### 4. Feature Test Suite (`feature_test_suite.sh`)

-

-**Purpose:** Comprehensive feature testing within bash itself (not comparing with fortsh).

-

-**What it tests:**

-- Basic output and echo

-- Redirection

-- Pipes

-- Command substitution

-- Variables

-- Parameter expansion

-- Brace expansion

-- Glob patterns

-- Arithmetic

-- Control flow

-- Test operators

-- Here documents

-- Background jobs

-- Special variables

-- Functions

-- Arrays

-- Quoting

-- Complex combinations

-

-**Total:** ~100+ feature tests

-

-**Run with:**

-```bash

-make test-features

-```

-

-**Expected runtime:** ~10-20 seconds

-

-## Running Tests

-

-### Quick Test

-Run a basic sanity check:

-```bash

-make test

-```

-

-### Smoke Tests

-Run quick validation tests:

-```bash

-make smoke-test

-```

-

-### Individual Test Suites

-Run specific test suites:

-```bash

-make test-integration   # Integration tests

-make test-parity        # Bash parity tests

-make test-posix         # POSIX compliance tests

-make test-features      # Feature tests

-```

-

-### All Tests

-Run the complete test suite:

-```bash

-make test-all

-```

-

-This runs:

-1. Integration tests

-2. Bash parity tests

-3. POSIX compliance tests

-

-**Expected total runtime:** ~1-2 minutes

-

-### Continuous Integration

-For CI/CD pipelines:

-```bash

-make clean all test-all

-```

-

-## Test Output Format

-

-All test scripts use a consistent format:

-

-```

-✓ PASS: Test description

-✗ FAIL: Test description

-  bash:   expected output

-  fortsh: actual output

-⊘ SKIP: Test description - reason

-```

-

-### Color Coding

-- 🟢 **Green**: Passed tests

-- 🔴 **Red**: Failed tests

-- 🟡 **Yellow**: Skipped tests

-- 🔵 **Blue**: Section headers

-

-## Test Results

-

-At the end of each suite, you'll see:

-

-```

-==========================================

-RESULTS

-==========================================

-Passed:  85

-Failed:  2

-Skipped: 3

-Total:   90

-==========================================

-Pass rate: 94%

-==========================================

-```

-

-## Exit Codes

-

-All test scripts follow standard conventions:

-- **0**: All tests passed

-- **1**: One or more tests failed

-

-## Adding New Tests

-

-### To bash_parity_test.sh

-

-Add a new comparison test:

-

-```bash

-compare_output "test description" "command to test"

-```

-

-Or compare exit codes:

-

-```bash

-compare_exit_code "test description" "command to test"

-```

-

-### To posix_compliance_test.sh

-

-Add a POSIX comparison test:

-

-```bash

-compare_posix_output "test description" "command to test"

-```

-

-Or compare exit codes:

-

-```bash

-compare_posix_exit_code "test description" "command to test"

-```

-

-### To integration_test.sh

-

-Add a new test section:

-

-```bash

-echo ""

-echo "Test N: Feature description"

-echo "----------------------------"

-result=$(echo "command" | "$FORTSH_BIN" 2>/dev/null)

-if [[ "$result" == "expected" ]]; then

-    echo "✅ Feature works"

-else

-    echo "❌ Feature failed"

-    echo "Expected: 'expected', Got: '$result'"

-fi

-```

-

-## Test Coverage

-

-Current coverage areas:

-

-### Fully Tested (100% parity with bash)

-- ✅ Variable expansion

-- ✅ Command substitution

-- ✅ Arithmetic expansion

-- ✅ Parameter expansion (basic)

-- ✅ Glob patterns

-- ✅ Redirection (basic)

-- ✅ Pipelines

-- ✅ For loops

-- ✅ While/until loops

-- ✅ If/elif/else

-- ✅ Case statements

-- ✅ Functions

-- ✅ Arrays (indexed)

-- ✅ Here-documents

-- ✅ Here-strings

-- ✅ Background jobs (&)

-- ✅ Logical operators (&&, ||)

-

-### Partially Tested (>90% parity)

-- ⚠️ Advanced parameter expansion

-- ⚠️ Associative arrays

-- ⚠️ Advanced redirection (FD manipulation)

-- ⚠️ Coprocesses

-- ⚠️ Process substitution

-

-### POSIX Compliance

-- ✅ All POSIX-required builtins

-- ✅ POSIX parameter expansion

-- ✅ POSIX test operators

-- ✅ POSIX control flow

-- ✅ POSIX quoting rules

-- ✅ POSIX word expansion order

-

-## Debugging Failed Tests

-

-### For Bash Parity Tests

-

-If a test fails, you'll see:

-

-```

-✗ FAIL: echo with quotes

-  bash:   hello world

-  fortsh: hello  world

-```

-

-To debug:

-```bash

-# Run the command manually

-bash -c 'echo "hello world"'

-./bin/fortsh -c 'echo "hello world"'

-

-# Compare output

-bash -c 'echo "hello world"' > /tmp/bash_out

-./bin/fortsh -c 'echo "hello world"' > /tmp/fortsh_out

-diff /tmp/bash_out /tmp/fortsh_out

-```

-

-### For POSIX Tests

-

-```bash

-# Run with POSIX shell

-sh -c 'command'

-./bin/fortsh -c 'command'

-```

-

-### Verbose Mode

-

-Add `-x` to any test script for verbose output:

-

-```bash

-bash -x tests/bash_parity_test.sh

-```

-

-## Test File Organization

-

-```

-tests/

-├── README.md                   # This file

-├── integration_test.sh         # Basic integration tests

-├── bash_parity_test.sh        # Bash compatibility tests

-├── posix_compliance_test.sh   # POSIX compliance tests

-├── feature_test_suite.sh      # Comprehensive feature tests

-└── [other test files]         # Legacy/specific tests

-```

-

-## Best Practices

-

-1. **Always run tests after changes:** `make test-all`

-2. **Add tests for new features:** Before implementing

-3. **Test edge cases:** Empty strings, special characters, etc.

-4. **Keep tests independent:** Each test should not depend on others

-5. **Use descriptive names:** Test names should explain what they verify

-6. **Clean up after tests:** Remove temp files in cleanup functions

-

-## Performance Benchmarks

-

-Typical execution times on modern hardware:

-

-| Test Suite | Tests | Time  | Tests/sec |

-|------------|-------|-------|-----------|

-| Integration| 8     | ~5s   | 1.6       |

-| Parity     | ~95   | ~45s  | 2.1       |

-| POSIX      | ~90   | ~40s  | 2.2       |

-| Features   | ~100  | ~15s  | 6.7       |

-| **Total**  | ~293  | ~105s | 2.8       |

-

-## Contributing

-

-When contributing new features:

-

-1. Write tests first (TDD)

-2. Ensure bash parity for bash-compatible features

-3. Ensure POSIX compliance for POSIX features

-4. Run `make test-all` before submitting

-5. Document any intentional deviations

-

-## Known Limitations

-

-Some bash features are intentionally not tested:

-- Bash-specific builtins not in POSIX

-- `[[` extended test (tested separately)

-- `(())` arithmetic command (tested separately)

-- Bash 4.x+ features (for compatibility)

-

-## License

-

-Tests are part of fortsh and follow the same license as the main project.

-

-## Support

-

-For test failures or questions:

-1. Check this documentation

-2. Review existing tests for examples

-3. Check fortsh documentation in `docs/`

-4. Open an issue on GitHub

-

----

-

-**Last Updated:** 2025-10-13

-**Test Suite Version:** 1.0

-**Fortsh Version:** 4.0.0+

-#!/bin/bash

-# =====================================

-# Bash Parity Test Suite for fortsh

-# =====================================

-# This test compares fortsh output with bash output to ensure compatibility

-

-set -e

-

-# Colors for output

-RED='\033[0;31m'

-GREEN='\033[0;32m'

-YELLOW='\033[1;33m'

-BLUE='\033[0;34m'

-NC='\033[0m' # No Color

-

-PASSED=0

-FAILED=0

-SKIPPED=0

-

-# Get script directory

-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

-FORTSH_BIN="${FORTSH_BIN:-$SCRIPT_DIR/../bin/fortsh}"

-

-# Check if fortsh exists

-if [[ ! -x "$FORTSH_BIN" ]]; then

-    echo -e "${RED}ERROR${NC}: fortsh binary not found at $FORTSH_BIN"

-    echo "Please run 'make' first or set FORTSH_BIN environment variable"

-    exit 1

-fi

-

-# Test result trackers

-pass() {

-    echo -e "${GREEN}✓ PASS${NC}: $1"

-    ((PASSED++))

-}

-

-fail() {

-    echo -e "${RED}✗ FAIL${NC}: $1"

-    if [[ -n "$2" ]]; then

-        echo "  bash:   $2"

-    fi

-    if [[ -n "$3" ]]; then

-        echo "  fortsh: $3"

-    fi

-    ((FAILED++))

-}

-

-skip() {

-    echo -e "${YELLOW}⊘ SKIP${NC}: $1 - $2"

-    ((SKIPPED++))

-}

-

-section() {

-    echo ""

-    echo -e "${BLUE}=========================================="

-    echo "$1"

-    echo -e "==========================================${NC}"

-}

-

-# Helper function to run command in both shells and compare

-compare_output() {

-    local test_name="$1"

-    local command="$2"

-    local bash_file="/tmp/bash_parity_$$_bash"

-    local fortsh_file="/tmp/bash_parity_$$_fortsh"

-

-    # Run in bash

-    bash -c "$command" > "$bash_file" 2>&1 || true

-

-    # Run in fortsh

-    "$FORTSH_BIN" -c "$command" > "$fortsh_file" 2>&1 || true

-

-    # Compare outputs

-    if diff -q "$bash_file" "$fortsh_file" > /dev/null 2>&1; then

-        pass "$test_name"

-    else

-        fail "$test_name" "$(cat "$bash_file")" "$(cat "$fortsh_file")"

-    fi

-

-    rm -f "$bash_file" "$fortsh_file"

-}

-

-# Helper function to compare exit codes

-compare_exit_code() {

-    local test_name="$1"

-    local command="$2"

-

-    bash -c "$command" > /dev/null 2>&1

-    local bash_exit=$?

-

-    "$FORTSH_BIN" -c "$command" > /dev/null 2>&1

-    local fortsh_exit=$?

-

-    if [[ $bash_exit -eq $fortsh_exit ]]; then

-        pass "$test_name"

-    else

-        fail "$test_name" "exit=$bash_exit" "exit=$fortsh_exit"

-    fi

-}

-

-# Cleanup

-cleanup() {

-    rm -f /tmp/bash_parity_$$_* 2>/dev/null

-    rm -f /tmp/fortsh_parity_test_* 2>/dev/null

-}

-trap cleanup EXIT

-

-section "1. BASIC ECHO AND OUTPUT"

-

-compare_output "echo simple string" "echo hello world"

-compare_output "echo with single quotes" "echo 'hello world'"

-compare_output "echo with double quotes" 'echo "hello world"'

-compare_output "echo with special chars" "echo 'hello\$world'"

-compare_output "echo multiple args" "echo a b c d e"

-

-section "2. VARIABLE EXPANSION"

-

-compare_output "simple variable" "VAR=test; echo \$VAR"

-compare_output "variable in string" 'VAR=world; echo "hello $VAR"'

-compare_output "multiple variables" "A=hello; B=world; echo \$A \$B"

-compare_output "undefined variable" "echo \$UNDEFINED_VAR_XYZ"

-compare_output "variable with braces" "VAR=test; echo \${VAR}"

-

-section "3. PARAMETER EXPANSION"

-

-compare_output "default value :-" 'echo "${UNSET:-default}"'

-compare_output "string length" 'STR=hello; echo "${#STR}"'

-compare_output "remove prefix #" 'VAR=prefix_value; echo "${VAR#prefix_}"'

-compare_output "remove prefix ##" 'VAR=path/to/file.txt; echo "${VAR##*/}"'

-compare_output "remove suffix %" 'VAR=file.txt; echo "${VAR%.txt}"'

-compare_output "remove suffix %%" 'VAR=file.tar.gz; echo "${VAR%%.*}"'

-compare_output "uppercase first" 'VAR=hello; echo "${VAR^}"'

-compare_output "uppercase all" 'VAR=hello; echo "${VAR^^}"'

-compare_output "lowercase first" 'VAR=HELLO; echo "${VAR,}"'

-compare_output "lowercase all" 'VAR=HELLO; echo "${VAR,,}"'

-

-section "4. COMMAND SUBSTITUTION"

-

-compare_output "command substitution \$()" "echo \$(echo nested)"

-compare_output "backtick substitution" 'echo `echo backtick`'

-compare_output "nested substitution" "echo \$(echo \$(echo deep))"

-compare_output "substitution in string" 'echo "result: $(echo success)"'

-

-section "5. ARITHMETIC EXPANSION"

-

-compare_output "simple addition" "echo \$((5 + 3))"

-compare_output "subtraction" "echo \$((10 - 7))"

-compare_output "multiplication" "echo \$((4 * 3))"

-compare_output "division" "echo \$((15 / 3))"

-compare_output "modulo" "echo \$((10 % 3))"

-compare_output "arithmetic with vars" "A=5; B=3; echo \$((A + B))"

-compare_output "complex expression" "echo \$((5 * 3 + 2))"

-

-section "6. BRACE EXPANSION"

-

-compare_output "numeric range" "echo {1..5}"

-compare_output "reverse range" "echo {5..1}"

-compare_output "char range" "echo {a..e}"

-compare_output "list expansion" "echo {foo,bar,baz}"

-compare_output "nested braces" "echo {a,b}{1,2}"

-

-section "7. GLOB PATTERNS"

-

-# Setup test files

-mkdir -p /tmp/fortsh_parity_test_dir

-touch /tmp/fortsh_parity_test_dir/{a,b,c}.txt

-touch /tmp/fortsh_parity_test_dir/test{1,2,3}.dat

-

-compare_output "glob wildcard *" "ls /tmp/fortsh_parity_test_dir/*.txt 2>/dev/null | wc -l"

-compare_output "glob single char ?" "ls /tmp/fortsh_parity_test_dir/?.txt 2>/dev/null | wc -l"

-compare_output "glob bracket" "ls /tmp/fortsh_parity_test_dir/[ab].txt 2>/dev/null | wc -l"

-

-section "8. REDIRECTION"

-

-compare_output "output redirect" "echo test > /tmp/fortsh_parity_test_out && cat /tmp/fortsh_parity_test_out"

-compare_output "append redirect" "echo line1 > /tmp/fortsh_parity_test_app && echo line2 >> /tmp/fortsh_parity_test_app && wc -l < /tmp/fortsh_parity_test_app"

-compare_output "here string" "cat <<< hello"

-compare_output "stderr redirect" "ls /nonexistent 2>&1 | grep -c 'cannot access\\|No such'"

-

-section "9. PIPELINES"

-

-compare_output "simple pipe" "echo hello | cat"

-compare_output "two-stage pipe" "echo test | cat | tr t T"

-compare_output "three-stage pipe" "echo HELLO | tr '[:upper:]' '[:lower:]' | tr l x"

-

-section "10. CONDITIONALS"

-

-compare_exit_code "true command" "true"

-compare_exit_code "false command" "false"

-compare_output "if true" "if true; then echo yes; fi"

-compare_output "if false" "if false; then echo no; else echo yes; fi"

-compare_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 "11. LOOPS"

-

-compare_output "for loop list" "for i in a b c; do echo \$i; done"

-compare_output "for loop range" "for i in {1..3}; do echo \$i; done"

-compare_output "for loop glob" "for f in /tmp/fortsh_parity_test_dir/*.txt; do basename \$f; done | wc -l"

-compare_output "while loop" "i=3; while [ \$i -gt 0 ]; do echo \$i; i=\$((i-1)); done"

-compare_output "until loop" "i=1; until [ \$i -gt 3 ]; do echo \$i; i=\$((i+1)); done"

-

-section "12. TEST OPERATORS"

-

-compare_exit_code "test -f file" "touch /tmp/fortsh_parity_test_file && test -f /tmp/fortsh_parity_test_file"

-compare_exit_code "test -d dir" "test -d /tmp"

-compare_exit_code "test -n string" "test -n 'hello'"

-compare_exit_code "test -z empty" "test -z ''"

-compare_exit_code "test string =" "test 'hello' = 'hello'"

-compare_exit_code "test number -eq" "test 5 -eq 5"

-compare_exit_code "test number -gt" "test 5 -gt 3"

-compare_exit_code "test number -lt" "test 3 -lt 5"

-

-section "13. LOGICAL OPERATORS"

-

-compare_exit_code "true && true" "true && true"

-compare_exit_code "true && false" "true && false"

-compare_exit_code "false || true" "false || true"

-compare_exit_code "false || false" "false || false"

-compare_output "command && echo" "true && echo success"

-compare_output "command || echo" "false || echo fallback"

-

-section "14. SPECIAL VARIABLES"

-

-compare_output "\$? exit status" "true; echo \$?"

-compare_output "\$? after failure" "false; echo \$?"

-compare_output "\$\$ PID exists" "test -n \$\$ && echo ok"

-

-section "15. FUNCTIONS"

-

-compare_output "simple function" "func() { echo hello; }; func"

-compare_output "function with args" "func() { echo \$1 \$2; }; func foo bar"

-compare_output "function return" "func() { return 42; }; func; echo \$?"

-compare_output "local variables" "func() { local x=10; echo \$x; }; func"

-

-section "16. ARRAYS"

-

-compare_output "array declaration" "arr=(a b c); echo \${arr[0]}"

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

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

-compare_output "array indices" "arr=(a b c); echo \${!arr[@]}"

-

-section "17. QUOTING AND ESCAPING"

-

-compare_output "single quote literal" "echo '\$VAR'"

-compare_output "double quote expand" 'VAR=test; echo "$VAR"'

-compare_output "escape in double" 'echo "hello\$world"'

-compare_output "escape newline" "echo 'line1\nline2'"

-

-section "18. SUBSHELLS"

-

-compare_output "subshell var isolation" "(VAR=inner; echo \$VAR); echo \$VAR"

-compare_output "subshell cd isolation" "(cd /tmp; pwd); pwd"

-

-section "19. CASE STATEMENT"

-

-compare_output "case match" "x=2; case \$x in 1) echo one;; 2) echo two;; esac"

-compare_output "case wildcard" "x=hello; case \$x in h*) echo starts_h;; esac"

-compare_output "case default" "x=z; case \$x in a) echo a;; *) echo default;; esac"

-

-section "20. MULTI-LINE STRINGS"

-

-compare_output "double quote multiline" 'echo "line1

-line2"'

-compare_output "single quote multiline" "echo 'line1

-line2'"

-

-# Summary

-section "SUMMARY"

-echo ""

-echo "=========================================="

-echo "BASH PARITY TEST RESULTS"

-echo "=========================================="

-echo -e "${GREEN}Passed:${NC}  $PASSED"

-echo -e "${RED}Failed:${NC}  $FAILED"

-echo -e "${YELLOW}Skipped:${NC} $SKIPPED"

-echo "Total:   $((PASSED + FAILED + SKIPPED))"

-echo "=========================================="

-

-if [[ $((PASSED + FAILED)) -gt 0 ]]; then

-    PASS_RATE=$((PASSED * 100 / (PASSED + FAILED)))

-    echo "Pass rate: ${PASS_RATE}%"

-fi

-

-if [[ $FAILED -eq 0 ]]; then

-    echo -e "${GREEN}ALL BASH PARITY TESTS PASSED!${NC} ✓"

-    exit 0

-else

-    echo -e "${RED}SOME TESTS FAILED${NC} ✗"

-    exit 1

-fi

-#!/bin/bash

-# Comprehensive Fortsh Feature Test Suite

-# Tests all major shell operators and features

-

-# Colors for output

-RED='\033[0;31m'

-GREEN='\033[0;32m'

-YELLOW='\033[1;33m'

-NC='\033[0m' # No Color

-

-PASSED=0

-FAILED=0

-SKIPPED=0

-

-# Test result tracker

-pass() {

-    echo -e "${GREEN}✓ PASS${NC}: $1"

-    ((PASSED++))

-}

-

-fail() {

-    echo -e "${RED}✗ FAIL${NC}: $1"

-    echo "  Error: $2"

-    ((FAILED++))

-}

-

-skip() {

-    echo -e "${YELLOW}⊘ SKIP${NC}: $1"

-    ((SKIPPED++))

-}

-

-section() {

-    echo ""

-    echo "=========================================="

-    echo "$1"

-    echo "=========================================="

-}

-

-# Cleanup function

-cleanup() {

-    rm -f /tmp/fortsh_test_* 2>/dev/null

-}

-

-# Setup

-cleanup

-trap cleanup EXIT

-

-section "1. BASIC OUTPUT & ECHO"

-

-# Test 1.1: Simple echo

-if echo "hello" > /tmp/fortsh_test_1 2>&1 && [ -f /tmp/fortsh_test_1 ]; then

-    pass "Simple echo"

-else

-    fail "Simple echo" "Command failed"

-fi

-

-# Test 1.2: Echo with variables

-VAR="world"

-if echo "$VAR" | grep -q "world"; then

-    pass "Echo with variables"

-else

-    fail "Echo with variables" "Variable not expanded"

-fi

-

-section "2. BASIC REDIRECTION"

-

-# Test 2.1: Output redirection (>)

-if echo "test" > /tmp/fortsh_test_2 && grep -q "test" /tmp/fortsh_test_2; then

-    pass "Output redirection (>)"

-else

-    fail "Output redirection (>)" "File not created or content wrong"

-fi

-

-# Test 2.2: Append redirection (>>)

-echo "line1" > /tmp/fortsh_test_3

-if echo "line2" >> /tmp/fortsh_test_3 && [ $(wc -l < /tmp/fortsh_test_3) -eq 2 ]; then

-    pass "Append redirection (>>)"

-else

-    fail "Append redirection (>>)" "Append failed"

-fi

-

-# Test 2.3: Input redirection (<)

-echo "input" > /tmp/fortsh_test_4

-if cat < /tmp/fortsh_test_4 | grep -q "input"; then

-    pass "Input redirection (<)"

-else

-    fail "Input redirection (<)" "Input not read"

-fi

-

-# Test 2.4: Error redirection (2>)

-ls /nonexistent 2> /tmp/fortsh_test_5

-if [ -s /tmp/fortsh_test_5 ]; then

-    pass "Error redirection (2>)"

-else

-    fail "Error redirection (2>)" "stderr not captured"

-fi

-

-# Test 2.5: Redirect both stdout and stderr (2>&1)

-if ls /nonexistent 2>&1 | grep -q "cannot access\|No such"; then

-    pass "Redirect stderr to stdout (2>&1)"

-else

-    fail "Redirect stderr to stdout (2>&1)" "Combined output failed"

-fi

-

-section "3. PIPES"

-

-# Test 3.1: Simple pipe

-if echo "hello" | cat | grep -q "hello"; then

-    pass "Simple pipe (echo | cat)"

-else

-    fail "Simple pipe" "Pipe failed"

-fi

-

-# Test 3.2: Two-stage pipe

-if echo "test" | cat | grep "test" > /dev/null; then

-    pass "Two-stage pipe"

-else

-    fail "Two-stage pipe" "Multi-stage pipe failed"

-fi

-

-# Test 3.3: Pipe with grep

-if ls / | grep -q "bin"; then

-    pass "Pipe with grep"

-else

-    fail "Pipe with grep" "Pipe to grep failed"

-fi

-

-# Test 3.4: Pipe with wc

-COUNT=$(echo -e "a\nb\nc" | wc -l)

-if [ "$COUNT" -eq 3 ]; then

-    pass "Pipe with wc"

-else

-    fail "Pipe with wc" "Expected 3, got $COUNT"

-fi

-

-# Test 3.5: Three-stage pipe

-if echo "HELLO" | tr '[:upper:]' '[:lower:]' | grep -q "hello"; then

-    pass "Three-stage pipe"

-else

-    fail "Three-stage pipe" "Complex pipe failed"

-fi

-

-section "4. COMMAND SUBSTITUTION"

-

-# Test 4.1: Backticks

-if [ "$(echo test)" = "test" ]; then

-    pass "Command substitution with $()"

-else

-    fail "Command substitution with $()" "Substitution failed"

-fi

-

-# Test 4.2: Nested substitution

-if [ "$(echo $(echo nested))" = "nested" ]; then

-    pass "Nested command substitution"

-else

-    fail "Nested command substitution" "Nested substitution failed"

-fi

-

-# Test 4.3: Substitution in echo

-OUTPUT=$(echo "Result: $(echo success)")

-if echo "$OUTPUT" | grep -q "Result: success"; then

-    pass "Command substitution in echo"

-else

-    fail "Command substitution in echo" "Got: $OUTPUT"

-fi

-

-section "5. VARIABLES"

-

-# Test 5.1: Simple variable assignment

-VAR1="value"

-if [ "$VAR1" = "value" ]; then

-    pass "Simple variable assignment"

-else

-    fail "Simple variable assignment" "Variable not set"

-fi

-

-# Test 5.2: Variable in command

-FILE="/tmp/fortsh_test_var"

-if echo "data" > "$FILE" && [ -f "$FILE" ]; then

-    pass "Variable in command"

-else

-    fail "Variable in command" "File not created"

-fi

-

-# Test 5.3: Command substitution to variable

-LINES=$(echo -e "a\nb" | wc -l)

-if [ "$LINES" -eq 2 ]; then

-    pass "Command substitution to variable"

-else

-    fail "Command substitution to variable" "Expected 2, got $LINES"

-fi

-

-section "6. PARAMETER EXPANSION"

-

-# Test 6.1: Default value

-UNSET_VAR=""

-if [ "${UNSET_VAR:-default}" = "default" ]; then

-    pass "Parameter expansion with default (:-)"

-else

-    fail "Parameter expansion with default" "Default not used"

-fi

-

-# Test 6.2: String length

-STR="hello"

-if [ "${#STR}" -eq 5 ]; then

-    pass "String length expansion (${#var})"

-else

-    fail "String length expansion" "Expected 5, got ${#STR}"

-fi

-

-# Test 6.3: Substring removal

-PATH_VAR="path/to/file.txt"

-if [ "${PATH_VAR##*/}" = "file.txt" ]; then

-    pass "Remove prefix (##)"

-else

-    fail "Remove prefix (##)" "Got: ${PATH_VAR##*/}"

-fi

-

-section "7. BRACE EXPANSION"

-

-# Test 7.1: Numeric range

-RESULT=$(echo {1..3})

-if [ "$RESULT" = "1 2 3" ]; then

-    pass "Brace expansion numeric range {1..3}"

-else

-    fail "Brace expansion numeric range" "Got: $RESULT"

-fi

-

-# Test 7.2: String list

-RESULT=$(echo {a,b,c})

-if echo "$RESULT" | grep -q "a b c"; then

-    pass "Brace expansion string list {a,b,c}"

-else