diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 86835dbb..23f2c194 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -31,7 +31,7 @@ Contributions are licensed under the [MIT License](https://github.com/TypedDevs/
 
 ### Prerequisites
 
-- Bash 3.2+
+- Bash 3.0+
 - Git
 - Make
 - [ShellCheck](https://github.com/koalaman/shellcheck#installing)
diff --git a/.github/workflows/tests-bash-3.0.yml b/.github/workflows/tests-bash-3.0.yml
new file mode 100644
index 00000000..bb2eb250
--- /dev/null
+++ b/.github/workflows/tests-bash-3.0.yml
@@ -0,0 +1,101 @@
+name: Bash 3.0 Compatibility
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  build-image:
+    name: "Build Bash 3.0 Image"
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Build Bash 3.0 Docker image
+        run: |
+          docker build -t bashunit-bash3 -f - . <<'EOF'
+          FROM debian:bullseye-slim
+
+          RUN apt-get update && apt-get install -y \
+              build-essential \
+              curl \
+              ca-certificates \
+              bison \
+              git \
+              procps \
+              && rm -rf /var/lib/apt/lists/*
+
+          WORKDIR /tmp
+          RUN curl -LO https://ftp.gnu.org/gnu/bash/bash-3.0.tar.gz \
+              && tar xzf bash-3.0.tar.gz \
+              && cd bash-3.0 \
+              && curl -fsSL -o support/config.guess 'https://raw.githubusercontent.com/gcc-mirror/gcc/master/config.guess' \
+              && curl -fsSL -o support/config.sub 'https://raw.githubusercontent.com/gcc-mirror/gcc/master/config.sub' \
+              && chmod +x support/config.guess support/config.sub \
+              && ./configure --prefix=/opt/bash-3.0 \
+              && make \
+              && make install \
+              && rm -rf /tmp/bash-3.0*
+
+          WORKDIR /bashunit
+          CMD ["/opt/bash-3.0/bin/bash", "--version"]
+          EOF
+
+      - name: Save Docker image
+        run: docker save bashunit-bash3 -o /tmp/bashunit-bash3.tar
+
+      - name: Upload Docker image artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: bashunit-bash3-image
+          path: /tmp/bashunit-bash3.tar
+          retention-days: 1
+
+  test:
+    name: "Bash 3.0 - ${{ matrix.name }}"
+    runs-on: ubuntu-latest
+    needs: build-image
+    timeout-minutes: 15
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: "Sequential"
+            flags: ""
+          - name: "Parallel"
+            flags: "--parallel"
+          - name: "Simple"
+            flags: "--simple"
+          - name: "Simple Parallel"
+            flags: "--simple --parallel"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Download Docker image artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: bashunit-bash3-image
+          path: /tmp
+
+      - name: Load Docker image
+        run: docker load --input /tmp/bashunit-bash3.tar
+
+      - name: Verify Bash 3.0 version
+        run: docker run --rm bashunit-bash3 /opt/bash-3.0/bin/bash --version
+
+      - name: Run tests with Bash 3.0 (${{ matrix.name }})
+        run: |
+          docker run --rm \
+            -v "$(pwd)":/bashunit \
+            -w /bashunit \
+            bashunit-bash3 \
+            /opt/bash-3.0/bin/bash ./bashunit ${{ matrix.flags }} tests/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bd40185e..24bdd42a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+### Changed
+- Lower minimum Bash version requirement from 3.2 to 3.0
+
 ### Added
 - Add Claude Code configuration with custom skills, agents, and rules
     - Custom skills for TDD workflow, test fixes, assertions, coverage, and releases
diff --git a/README.md b/README.md
index 4bab7005..373cd051 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ You can find the complete documentation for **bashunit** online, including insta
 
 ## Requirements
 
-bashunit requires **Bash 3.2** or newer.
+bashunit requires **Bash 3.0** or newer.
 
 ## Contribute
 
diff --git a/bashunit b/bashunit
index 4f547107..a7582db5 100755
--- a/bashunit
+++ b/bashunit
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-declare -r BASHUNIT_MIN_BASH_VERSION="3.2"
+declare -r BASHUNIT_MIN_BASH_VERSION="3.0"
 
 function _check_bash_version() {
   local current_version
@@ -16,10 +16,10 @@ function _check_bash_version() {
     current_version="$(bash --version | head -n1 | cut -d' ' -f4 | cut -d. -f1,2)"
   fi
 
-  local major minor
-  IFS=. read -r major minor _ <<< "$current_version"
+  local major
+  IFS=. read -r major _ <<<"$current_version"
 
-  if (( major < 3 )) || { (( major == 3 )) && (( minor < 2 )); }; then
+  if ((major < 3)); then
     printf 'Bashunit requires Bash >= %s. Current version: %s\n' "$BASHUNIT_MIN_BASH_VERSION" "$current_version" >&2
     exit 1
   fi
@@ -41,16 +41,16 @@ export BASHUNIT_WORKING_DIR
 # Early scan for flags that must be set before loading env.sh
 for arg in "$@"; do
   case "$arg" in
-    --skip-env-file)
-      export BASHUNIT_SKIP_ENV_FILE=true
-      ;;
-    -l|--login)
-      export BASHUNIT_LOGIN_SHELL=true
-      ;;
-    --no-color)
-      # shellcheck disable=SC2034
-      BASHUNIT_NO_COLOR=true
-      ;;
+  --skip-env-file)
+    export BASHUNIT_SKIP_ENV_FILE=true
+    ;;
+  -l | --login)
+    export BASHUNIT_LOGIN_SHELL=true
+    ;;
+  --no-color)
+    # shellcheck disable=SC2034
+    BASHUNIT_NO_COLOR=true
+    ;;
   esac
 done
 
@@ -88,39 +88,39 @@ bashunit::clock::init
 _SUBCOMMAND=""
 
 case "${1:-}" in
-  test|bench|doc|init|learn|upgrade|assert)
-    _SUBCOMMAND="$1"
-    shift
-    ;;
-  -v|--version)
-    bashunit::console_header::print_version
-    exit 0
-    ;;
-  -h|--help)
-    bashunit::console_header::print_help
-    exit 0
-    ;;
-  -*)
-    # Flag without subcommand → assume "test"
-    _SUBCOMMAND="test"
-    ;;
-  "")
-    # No arguments → assume "test" (uses BASHUNIT_DEFAULT_PATH)
-    _SUBCOMMAND="test"
-    ;;
-  *)
-    # Path argument → assume "test"
-    _SUBCOMMAND="test"
-    ;;
+test | bench | doc | init | learn | upgrade | assert)
+  _SUBCOMMAND="$1"
+  shift
+  ;;
+-v | --version)
+  bashunit::console_header::print_version
+  exit 0
+  ;;
+-h | --help)
+  bashunit::console_header::print_help
+  exit 0
+  ;;
+-*)
+  # Flag without subcommand → assume "test"
+  _SUBCOMMAND="test"
+  ;;
+"")
+  # No arguments → assume "test" (uses BASHUNIT_DEFAULT_PATH)
+  _SUBCOMMAND="test"
+  ;;
+*)
+  # Path argument → assume "test"
+  _SUBCOMMAND="test"
+  ;;
 esac
 
 # Route to subcommand handler
 case "$_SUBCOMMAND" in
-  test)    bashunit::main::cmd_test "$@" ;;
-  bench)   bashunit::main::cmd_bench "$@" ;;
-  doc)     bashunit::main::cmd_doc "$@" ;;
-  init)    bashunit::main::cmd_init "$@" ;;
-  learn)   bashunit::main::cmd_learn "$@" ;;
-  upgrade) bashunit::main::cmd_upgrade "$@" ;;
-  assert)  bashunit::main::cmd_assert "$@" ;;
+test) bashunit::main::cmd_test "$@" ;;
+bench) bashunit::main::cmd_bench "$@" ;;
+doc) bashunit::main::cmd_doc "$@" ;;
+init) bashunit::main::cmd_init "$@" ;;
+learn) bashunit::main::cmd_learn "$@" ;;
+upgrade) bashunit::main::cmd_upgrade "$@" ;;
+assert) bashunit::main::cmd_assert "$@" ;;
 esac
diff --git a/bin/create-pr b/bin/create-pr
index 5560422e..be05d558 100755
--- a/bin/create-pr
+++ b/bin/create-pr
@@ -21,7 +21,7 @@ function console_header::print_version() {
 }
 
 function console_header::print_help() {
-    cat <<EOF
+  cat <<EOF
 create-pr [arguments] [options]
 
 Arguments:
@@ -59,8 +59,8 @@ set -o allexport
 [[ -f ".env" ]] && source .env set
 set +o allexport
 
-APP_CREATE_PR_ROOT_DIR=${APP_CREATE_PR_ROOT_DIR:-"$(git rev-parse --show-toplevel)"} \
-  || error_and_exit "This directory is not a git repository"
+APP_CREATE_PR_ROOT_DIR=${APP_CREATE_PR_ROOT_DIR:-"$(git rev-parse --show-toplevel)"} ||
+  error_and_exit "This directory is not a git repository"
 PR_LINK_PREFIX_TEXT=${PR_LINK_PREFIX_TEXT:-""}
 PR_TICKET_LINK_PREFIX=${PR_TICKET_LINK_PREFIX:-""}
 PR_TEMPLATE_PATH=${PR_TEMPLATE_PATH:-".github/PULL_REQUEST_TEMPLATE.md"}
@@ -71,8 +71,8 @@ PR_ASSIGNEE=${PR_ASSIGNEE:-${ASSIGNEE:-"@me"}}
 PR_REVIEWER=${PR_REVIEWER:-${REVIEWER:-""}}
 PR_RUN_AFTER_CREATION=${PR_RUN_AFTER_CREATION:-""}
 TARGET_BRANCH=${TARGET_BRANCH:-"main"}
-CURRENT_BRANCH=${CURRENT_BRANCH:-"$(git rev-parse --abbrev-ref HEAD 2>/dev/null)"} \
-  || error_and_exit "Failed to get the current branch name."
+CURRENT_BRANCH=${CURRENT_BRANCH:-"$(git rev-parse --abbrev-ref HEAD 2>/dev/null)"} ||
+  error_and_exit "Failed to get the current branch name."
 
 REMOTE_URL=${REMOTE_URL:-"$(git config --get remote.origin.url)"}
 if [[ "$REMOTE_URL" == *"github.com"* ]]; then
@@ -121,8 +121,8 @@ function main::create_pr() {
 
   # Push the current branch
   if ! git push -u origin "$CURRENT_BRANCH"; then
-      error_and_exit "Failed to push the current branch to the remote repository."\
-        "Please check your git remote settings."
+    error_and_exit "Failed to push the current branch to the remote repository." \
+      "Please check your git remote settings."
   fi
 
   if [[ "$PR_USING_CLIENT" == "gitlab" ]]; then
@@ -137,13 +137,13 @@ function main::create_pr_gitlab() {
 
   local glab_command=(
     glab mr create
-      --title "$PR_TITLE"
-      --target-branch "$TARGET_BRANCH"
-      --source-branch "$CURRENT_BRANCH"
-      --assignee "$PR_ASSIGNEE"
-      --reviewer "$PR_REVIEWER"
-      --label "$PR_LABEL"
-      --description "$PR_BODY"
+    --title "$PR_TITLE"
+    --target-branch "$TARGET_BRANCH"
+    --source-branch "$CURRENT_BRANCH"
+    --assignee "$PR_ASSIGNEE"
+    --reviewer "$PR_REVIEWER"
+    --label "$PR_LABEL"
+    --description "$PR_BODY"
   )
 
   if [[ ${#EXTRA_ARGS[@]} -gt 0 ]]; then
@@ -163,13 +163,13 @@ function main::create_pr_github() {
 
   local gh_command=(
     gh pr create
-      --title "$PR_TITLE"
-      --base "$TARGET_BRANCH"
-      --head "$CURRENT_BRANCH"
-      --assignee "$PR_ASSIGNEE"
-      --reviewer "$PR_REVIEWER"
-      --label "$PR_LABEL"
-      --body "$PR_BODY"
+    --title "$PR_TITLE"
+    --base "$TARGET_BRANCH"
+    --head "$CURRENT_BRANCH"
+    --assignee "$PR_ASSIGNEE"
+    --reviewer "$PR_REVIEWER"
+    --label "$PR_LABEL"
+    --body "$PR_BODY"
   )
 
   if [[ ${#EXTRA_ARGS[@]} -gt 0 ]]; then
@@ -177,8 +177,8 @@ function main::create_pr_github() {
   fi
 
   if ! "${gh_command[@]}"; then
-      error_and_exit "Failed to create the Pull Request." \
-        "Ensure you have the correct permissions and the repository is properly configured."
+    error_and_exit "Failed to create the Pull Request." \
+      "Ensure you have the correct permissions and the repository is properly configured."
   fi
 
   main::run_after_creation_script
@@ -287,7 +287,7 @@ function pr_label() {
   IFS=';' # Split mapping entries by semicolon
   for entry in $mapping; do
     # Split each entry into keys and value
-    IFS=':' read -r keys value <<< "$entry"
+    IFS=':' read -r keys value <<<"$entry"
 
     # Check if the prefix matches any of the keys
     IFS='|' # Split keys by pipe symbol
@@ -388,7 +388,7 @@ function pr_title() {
   fi
 
   local title
-  title=$(echo "$branch_name" | cut -d'-' -f3- | tr '-' ' '| tr '_' ' ')
+  title=$(echo "$branch_name" | cut -d'-' -f3- | tr '-' ' ' | tr '_' ' ')
   title="$(echo "${title:0:1}" | tr '[:lower:]' '[:upper:]')${title:1}"
 
   # Normalize the template by removing spaces around placeholders
@@ -404,7 +404,7 @@ function pr_title() {
 
   if [[ -n "$PR_TITLE_REMOVE_PREFIX" ]]; then
     # Split PR_TITLE_REMOVE_PREFIX into an array
-    IFS=',' read -ra prefixes <<< "$PR_TITLE_REMOVE_PREFIX"
+    IFS=',' read -ra prefixes <<<"$PR_TITLE_REMOVE_PREFIX"
     # Loop through each prefix and remove it from the start if it matches
     for prefix in "${prefixes[@]}"; do
       # shellcheck disable=SC2001
@@ -412,9 +412,9 @@ function pr_title() {
     done
 
     # Trim leading whitespace and capitalize the first letter
-    new_title=$(echo "$new_title" \
-      | sed 's/^ *//' \
-      | awk '{ print toupper(substr($0,1,1)) tolower(substr($0,2)) }')
+    new_title=$(echo "$new_title" |
+      sed 's/^ *//' |
+      awk '{ print toupper(substr($0,1,1)) tolower(substr($0,2)) }')
   fi
 
   formatted="${formatted//\{\{PR_TITLE\}\}/$new_title}"
@@ -450,8 +450,8 @@ GH_CLI_INSTALLATION_URL="https://cli.github.com/"
 GLAB_CLI_INSTALLATION_URL="https://gitlab.com/gitlab-org/cli/"
 
 function error_and_exit() {
-    echo "Error: $1" >&2
-    exit 1
+  echo "Error: $1" >&2
+  exit 1
 }
 
 function validate::target_branch_exists() {
@@ -473,13 +473,13 @@ function validate::current_branch_is_not_target() {
 }
 
 function validate::gh_cli_is_installed() {
-  if ! command -v gh &> /dev/null; then
+  if ! command -v gh &>/dev/null; then
     error_and_exit "gh CLI is not installed. Please install it from $GH_CLI_INSTALLATION_URL and try again."
   fi
 }
 
 function validate::glab_cli_is_installed() {
-  if ! command -v glab &> /dev/null; then
+  if ! command -v glab &>/dev/null; then
     error_and_exit "glab CLI is not installed. Please install it from $GLAB_CLI_INSTALLATION_URL and try again."
   fi
 }
@@ -493,38 +493,38 @@ declare -r CREATE_PR_VERSION="0.10.0"
 CREATE_PR_ROOT_DIR="$(dirname "${BASH_SOURCE[0]}")"
 export CREATE_PR_ROOT_DIR
 
-
 DRY_RUN=${DRY_RUN:-false}
 EXTRA_ARGS=()
 
 while [[ $# -gt 0 ]]; do
   argument="$1"
   case $argument in
-    --debug)
-      set -x
-      ;;
-    --dry-run)
-      DRY_RUN=true
-      ;;
-    -e|--env)
-      # shellcheck disable=SC1090
-      source "$2"
-      shift
-      ;;
-    -t|--title)
-      helpers::generate_branch_name "$2" "${3:-}"
-      trap '' EXIT && exit 0
-      ;;
-    -h|--help)
-      console_header::print_help
-      trap '' EXIT && exit 0
-      ;;
-    -v|--version)
-      console_header::print_version
-      trap '' EXIT && exit 0
-      ;;
-    *)
-      EXTRA_ARGS+=("$argument")
+  --debug)
+    set -x
+    ;;
+  --dry-run)
+    DRY_RUN=true
+    ;;
+  -e | --env)
+    # shellcheck disable=SC1090
+    source "$2"
+    shift
+    ;;
+  -t | --title)
+    helpers::generate_branch_name "$2" "${3:-}"
+    trap '' EXIT && exit 0
+    ;;
+  -h | --help)
+    console_header::print_help
+    trap '' EXIT && exit 0
+    ;;
+  -v | --version)
+    console_header::print_version
+    trap '' EXIT && exit 0
+    ;;
+  *)
+    EXTRA_ARGS+=("$argument")
+    ;;
   esac
   shift
 done
diff --git a/bin/pre-commit b/bin/pre-commit
index f0f1e813..39a57cf0 100755
--- a/bin/pre-commit
+++ b/bin/pre-commit
@@ -5,9 +5,9 @@ make pre_commit/run
 EXIT_CODE=$?
 
 if [[ ${EXIT_CODE} -ne 0 ]]; then
-    echo "Pre Commit checks failed. Please fix the above issues before committing"
-    exit ${EXIT_CODE}
+  echo "Pre Commit checks failed. Please fix the above issues before committing"
+  exit ${EXIT_CODE}
 else
-    echo "Pre Commit checks passed, no problems found"
-    exit 0
+  echo "Pre Commit checks passed, no problems found"
+  exit 0
 fi
diff --git a/build.sh b/build.sh
index 83aeaa6a..6963c94a 100755
--- a/build.sh
+++ b/build.sh
@@ -39,15 +39,15 @@ function build::generate_bin() {
   local temp
   temp="$(dirname "$out")/temp.sh"
 
-  echo '#!/usr/bin/env bash' > "$temp"
+  echo '#!/usr/bin/env bash' >"$temp"
   echo "Generating bashunit in the '$(dirname "$out")' folder..."
 
   for file in $(build::dependencies); do
     build::process_file "$file" "$temp"
   done
 
-  cat bashunit >> "$temp"
-  grep -v '^source' "$temp" > "$out"
+  cat bashunit >>"$temp"
+  grep -v '^source' "$temp" >"$out"
   rm "$temp"
   chmod u+x "$out"
 
@@ -62,9 +62,9 @@ function build::process_file() {
 
   {
     echo "# $(basename "$file")"
-    tail -n +2 "$file" >> "$temp"
+    tail -n +2 "$file" >>"$temp"
     echo ""
-  } >> "$temp"
+  } >>"$temp"
 
   # Search for any 'source' lines in the current file
   grep '^source ' "$file" | while read -r line; do
@@ -76,7 +76,8 @@ function build::process_file() {
     sourced_file=$(eval echo "$sourced_file")
 
     # Handle relative paths if necessary
-    if [[ ! "$sourced_file" =~ ^/ ]]; then
+    local _absolute_path_pattern='^/'
+    if [[ ! "$sourced_file" =~ $_absolute_path_pattern ]]; then
       sourced_file="$(dirname "$file")/$sourced_file"
     fi
 
@@ -139,7 +140,7 @@ function build::embed_docs() {
 
     # Print everything after the end marker
     sed -n '/# __BASHUNIT_EMBEDDED_DOCS_END__/,$p' "$file" | tail -n +2
-  } > "$temp_file"
+  } >"$temp_file"
 
   mv "$temp_file" "$file"
   chmod u+x "$file"
@@ -159,7 +160,7 @@ function build::generate_checksum() {
     checksum=$(sha256sum "$out")
   fi
 
-  echo "$checksum" > "$(dirname "$out")/checksum"
+  echo "$checksum" >"$(dirname "$out")/checksum"
   echo "$checksum"
 }
 
@@ -173,15 +174,15 @@ SHOULD_CLEANUP=false
 
 for arg in "$@"; do
   case $arg in
-    -v|--verify)
-      SHOULD_VERIFY_BUILD=true
-      ;;
-    -c|--cleanup)
-      SHOULD_CLEANUP=true
-      ;;
-    *)
-      DIR=$arg
-      ;;
+  -v | --verify)
+    SHOULD_VERIFY_BUILD=true
+    ;;
+  -c | --cleanup)
+    SHOULD_CLEANUP=true
+    ;;
+  *)
+    DIR=$arg
+    ;;
   esac
 done
 
diff --git a/docs/installation.md b/docs/installation.md
index 2d2708a5..4c23c542 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -7,7 +7,7 @@ Here, we provide different options that you can use to install **bashunit** in y
 
 ## Requirements
 
-bashunit requires **Bash 3.2** or newer.
+bashunit requires **Bash 3.0** or newer.
 
 ## install.sh
 
diff --git a/example/custom_functions.sh b/example/custom_functions.sh
index a0b1a9f3..7d363cac 100755
--- a/example/custom_functions.sh
+++ b/example/custom_functions.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
 
-function say_hi(){
+function say_hi() {
   echo "Hi, $1!"
 }
diff --git a/install.sh b/install.sh
index 7749ef0c..80411e34 100755
--- a/install.sh
+++ b/install.sh
@@ -2,8 +2,13 @@
 # shellcheck disable=SC2155
 # shellcheck disable=SC2164
 
+# Helper function for regex matching (Bash 3.0+ compatible)
+function regex_match() {
+  [[ $1 =~ $2 ]]
+}
+
 function is_git_installed() {
-  command -v git > /dev/null 2>&1
+  command -v git >/dev/null 2>&1
 }
 
 function build_and_install_beta() {
@@ -39,9 +44,9 @@ function install() {
     echo "> Downloading the latest version: '$TAG'"
   fi
 
-  if command -v curl > /dev/null 2>&1; then
+  if command -v curl >/dev/null 2>&1; then
     curl -L -O -J "$BASHUNIT_GIT_REPO/releases/download/$TAG/bashunit" 2>/dev/null
-  elif command -v wget > /dev/null 2>&1; then
+  elif command -v wget >/dev/null 2>&1; then
     wget "$BASHUNIT_GIT_REPO/releases/download/$TAG/bashunit" 2>/dev/null
   else
     echo "Cannot download bashunit: curl or wget not found."
@@ -58,7 +63,7 @@ DIR="lib"
 VERSION="latest"
 
 function is_version() {
-  [[ "$1" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ || "$1" == "latest" || "$1" == "beta" ]]
+  regex_match "$1" '^[0-9]+\.[0-9]+\.[0-9]+$' || [[ "$1" == "latest" || "$1" == "beta" ]]
 }
 
 # Parse arguments flexibly
diff --git a/release.sh b/release.sh
index 0b71855d..32a33e0e 100755
--- a/release.sh
+++ b/release.sh
@@ -15,6 +15,11 @@ GITHUB_REPO_PATH="TypedDevs/bashunit"
 GITHUB_REPO_URL="https://github.com/${GITHUB_REPO_PATH}"
 RELEASE_FILES=("bashunit" "install.sh" "package.json" "CHANGELOG.md")
 
+# Helper function for regex matching (Bash 3.0+ compatible)
+function regex_match() {
+  [[ $1 =~ $2 ]]
+}
+
 # Colors
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -391,19 +396,19 @@ function release::sandbox::mock_gh() {
   gh() {
     release::log_sandbox "Would execute: gh $*"
     case "$1" in
-      release)
-        release::log_sandbox "GitHub release would be created"
-        return 0
-        ;;
-      api)
-        # Return empty for contributor lookup
-        echo ""
-        return 0
-        ;;
-      auth)
-        # Auth status check - return success in sandbox
-        return 0
-        ;;
+    release)
+      release::log_sandbox "GitHub release would be created"
+      return 0
+      ;;
+    api)
+      # Return empty for contributor lookup
+      echo ""
+      return 0
+      ;;
+    auth)
+      # Auth status check - return success in sandbox
+      return 0
+      ;;
     esac
     return 0
   }
@@ -453,7 +458,7 @@ function release::sandbox::cleanup() {
   echo -en "${YELLOW}Keep sandbox for inspection? [y/N]: ${NC}" >&2
   read -r response
 
-  if [[ "$response" =~ ^[Yy]$ ]]; then
+  if regex_match "$response" '^[Yy]$'; then
     release::log_info "Sandbox preserved at: $SANDBOX_DIR"
     release::log_info "To clean up later: rm -rf $SANDBOX_DIR"
   else
@@ -504,7 +509,7 @@ function release::sandbox::run() {
   # Generate release notes
   RELEASE_NOTES_FILE="/tmp/bashunit-release-notes-${VERSION}.md"
   CHECKSUM=$(release::get_checksum)
-  release::generate_release_notes "$VERSION" "$CURRENT_VERSION" "$CHECKSUM" > "$RELEASE_NOTES_FILE"
+  release::generate_release_notes "$VERSION" "$CURRENT_VERSION" "$CHECKSUM" >"$RELEASE_NOTES_FILE"
   release::log_success "Generated release notes"
 
   # Show what would happen with push/gh release
@@ -529,7 +534,7 @@ function release::sandbox::run() {
 
 function release::validate_semver() {
   local version=$1
-  if [[ ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+  if ! regex_match "$version" '^[0-9]+\.[0-9]+\.[0-9]+$'; then
     release::log_error "Invalid version format: $version"
     release::log_error "Version must be in semver format (e.g., 0.30.0)"
     exit $EXIT_VALIDATION_ERROR
@@ -552,10 +557,10 @@ function release::version_gt() {
   local i
   local ver1
   local ver2
-  IFS=. read -ra ver1 <<< "$v1"
-  IFS=. read -ra ver2 <<< "$v2"
+  IFS=. read -ra ver1 <<<"$v1"
+  IFS=. read -ra ver2 <<<"$v2"
 
-  for ((i=0; i<3; i++)); do
+  for ((i = 0; i < 3; i++)); do
     if ((ver1[i] > ver2[i])); then
       return 0
     elif ((ver1[i] < ver2[i])); then
@@ -652,10 +657,10 @@ function release::generate_release_notes() {
 
   # Extract content from the latest version header (first ## [) until the next version header
   # Transform changelog sections to release format with emojis
-  awk '/^## \[/{if(found) exit; found=1; next} found' CHANGELOG.md | \
-    sed 's/^### Added$/## ✨ Improvements/' | \
-    sed 's/^### Changed$/## 🛠️ Changes/' | \
-    sed 's/^### Fixed$/## 🐛 Bug Fixes/' | \
+  awk '/^## \[/{if(found) exit; found=1; next} found' CHANGELOG.md |
+    sed 's/^### Added$/## ✨ Improvements/' |
+    sed 's/^### Changed$/## 🛠️ Changes/' |
+    sed 's/^### Fixed$/## 🐛 Bug Fixes/' |
     sed 's/^### Performance$/## ⚡ Performance/'
 
   # Add contributors section
@@ -752,7 +757,7 @@ function release::confirm_action() {
   echo -en "${YELLOW}$prompt [y/N]: ${NC}" >&2
   read -r response
 
-  if [[ "$response" =~ ^[Yy]$ ]]; then
+  if regex_match "$response" '^[Yy]$'; then
     return 0
   else
     return 1
@@ -866,48 +871,48 @@ function release::main() {
   # Parse arguments
   while [[ $# -gt 0 ]]; do
     case $1 in
-      --dry-run)
-        DRY_RUN=true
-        shift
-        ;;
-      --sandbox)
-        SANDBOX_MODE=true
-        shift
-        ;;
-      --force)
-        FORCE_MODE=true
-        shift
-        ;;
-      --verbose)
-        VERBOSE_MODE=true
-        shift
-        ;;
-      --json)
-        JSON_OUTPUT=true
-        shift
-        ;;
-      --without-gh-release)
-        WITH_GH_RELEASE=false
-        shift
-        ;;
-      --rollback)
-        release::rollback::manual
-        exit $?
-        ;;
-      -h|--help)
+    --dry-run)
+      DRY_RUN=true
+      shift
+      ;;
+    --sandbox)
+      SANDBOX_MODE=true
+      shift
+      ;;
+    --force)
+      FORCE_MODE=true
+      shift
+      ;;
+    --verbose)
+      VERBOSE_MODE=true
+      shift
+      ;;
+    --json)
+      JSON_OUTPUT=true
+      shift
+      ;;
+    --without-gh-release)
+      WITH_GH_RELEASE=false
+      shift
+      ;;
+    --rollback)
+      release::rollback::manual
+      exit $?
+      ;;
+    -h | --help)
+      release::show_usage
+      exit $EXIT_SUCCESS
+      ;;
+    *)
+      if [[ -z "$VERSION" ]]; then
+        VERSION=$1
+      else
+        release::log_error "Unknown argument: $1"
         release::show_usage
-        exit $EXIT_SUCCESS
-        ;;
-      *)
-        if [[ -z "$VERSION" ]]; then
-          VERSION=$1
-        else
-          release::log_error "Unknown argument: $1"
-          release::show_usage
-          exit $EXIT_VALIDATION_ERROR
-        fi
-        shift
-        ;;
+        exit $EXIT_VALIDATION_ERROR
+      fi
+      shift
+      ;;
     esac
   done
 
@@ -1001,7 +1006,7 @@ function release::main() {
     release::generate_release_notes "$VERSION" "$CURRENT_VERSION" "$CHECKSUM" >&2
     echo "----------------------------------------" >&2
   else
-    release::generate_release_notes "$VERSION" "$CURRENT_VERSION" "$CHECKSUM" > "$RELEASE_NOTES_FILE"
+    release::generate_release_notes "$VERSION" "$CURRENT_VERSION" "$CHECKSUM" >"$RELEASE_NOTES_FILE"
     release::log_success "Saved release notes to $RELEASE_NOTES_FILE"
   fi
   release::state::record_step "generate_release_notes"
diff --git a/src/assert.sh b/src/assert.sh
index 690e4bd5..a39ab75b 100755
--- a/src/assert.sh
+++ b/src/assert.sh
@@ -8,7 +8,7 @@ function bashunit::assert::mark_failed() {
 
 # Guard clause to skip assertion if one already failed in test (when stop-on-assertion is enabled)
 function bashunit::assert::should_skip() {
-  bashunit::env::is_stop_on_assertion_failure_enabled && (( _BASHUNIT_ASSERTION_FAILED_IN_TEST ))
+  bashunit::env::is_stop_on_assertion_failure_enabled && ((_BASHUNIT_ASSERTION_FAILED_IN_TEST))
 }
 
 function bashunit::fail() {
@@ -31,8 +31,14 @@ function assert_true() {
 
   # Check for expected literal values first
   case "$actual" in
-    "true"|"0") bashunit::state::add_assertions_passed; return ;;
-    "false"|"1") bashunit::handle_bool_assertion_failure "true or 0" "$actual"; return ;;
+  "true" | "0")
+    bashunit::state::add_assertions_passed
+    return
+    ;;
+  "false" | "1")
+    bashunit::handle_bool_assertion_failure "true or 0" "$actual"
+    return
+    ;;
   esac
 
   # Run command or eval and check the exit code
@@ -53,8 +59,14 @@ function assert_false() {
 
   # Check for expected literal values first
   case "$actual" in
-    "false"|"1") bashunit::state::add_assertions_passed; return ;;
-    "true"|"0") bashunit::handle_bool_assertion_failure "false or 1" "$actual"; return ;;
+  "false" | "1")
+    bashunit::state::add_assertions_passed
+    return
+    ;;
+  "true" | "0")
+    bashunit::handle_bool_assertion_failure "false or 1" "$actual"
+    return
+    ;;
   esac
 
   # Run command or eval and check the exit code
@@ -71,12 +83,16 @@ function assert_false() {
 function bashunit::run_command_or_eval() {
   local cmd="$1"
 
-  if [[ "$cmd" =~ ^eval ]]; then
-    eval "${cmd#eval }" &> /dev/null
-  elif [[ "$(command -v "$cmd")" =~ ^alias ]]; then
-    eval "$cmd" &> /dev/null
+  local _re='^eval'
+  if [[ "$cmd" =~ $_re ]]; then
+    eval "${cmd#eval }" &>/dev/null
   else
-    "$cmd" &> /dev/null
+    _re='^alias'
+    if [[ "$(command -v "$cmd")" =~ $_re ]]; then
+      eval "$cmd" &>/dev/null
+    else
+      "$cmd" &>/dev/null
+    fi
   fi
   return $?
 }
@@ -219,7 +235,8 @@ function assert_contains() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
@@ -242,20 +259,23 @@ function assert_contains_ignore_case() {
   local expected="$1"
   local actual="$2"
 
-  shopt -s nocasematch
+  # Bash 3.0 compatible: use tr for case-insensitive comparison
+  # (shopt nocasematch was introduced in Bash 3.1)
+  local expected_lower
+  local actual_lower
+  expected_lower=$(printf '%s' "$expected" | tr '[:upper:]' '[:lower:]')
+  actual_lower=$(printf '%s' "$actual" | tr '[:upper:]' '[:lower:]')
 
-  if ! [[ $actual =~ $expected ]]; then
+  if [[ "$actual_lower" != *"$expected_lower"* ]]; then
     local test_fn
     test_fn="$(bashunit::helper::find_test_function_name)"
     local label
     label="$(bashunit::helper::normalize_test_function_name "$test_fn")"
     bashunit::assert::mark_failed
     bashunit::console_results::print_failed_test "${label}" "${actual}" "to contain" "${expected}"
-    shopt -u nocasematch
     return
   fi
 
-  shopt -u nocasematch
   bashunit::state::add_assertions_passed
 }
 
@@ -263,7 +283,8 @@ function assert_not_contains() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
@@ -284,11 +305,12 @@ function assert_matches() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
-  if ! [[ $actual =~ $expected ]]; then
+  if ! [[ "$actual" =~ $expected ]]; then
     local test_fn
     test_fn="$(bashunit::helper::find_test_function_name)"
     local label
@@ -305,11 +327,12 @@ function assert_not_matches() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
-  if [[ $actual =~ $expected ]]; then
+  if [[ "$actual" =~ $expected ]]; then
     local test_fn
     test_fn="$(bashunit::helper::find_test_function_name)"
     local label
@@ -336,23 +359,23 @@ function assert_exec() {
 
   while [[ $# -gt 0 ]]; do
     case "$1" in
-      --exit)
-        expected_exit="$2"
-        shift 2
-        ;;
-      --stdout)
-        expected_stdout="$2"
-        check_stdout=true
-        shift 2
-        ;;
-      --stderr)
-        expected_stderr="$2"
-        check_stderr=true
-        shift 2
-        ;;
-      *)
-        shift
-        ;;
+    --exit)
+      expected_exit="$2"
+      shift 2
+      ;;
+    --stdout)
+      expected_stdout="$2"
+      check_stdout=true
+      shift 2
+      ;;
+    --stderr)
+      expected_stderr="$2"
+      check_stderr=true
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
     esac
   done
 
@@ -379,16 +402,16 @@ function assert_exec() {
   fi
 
   if $check_stdout; then
-    expected_desc+=$'\n'"stdout: $expected_stdout"
-    actual_desc+=$'\n'"stdout: $stdout"
+    expected_desc="$expected_desc"$'\n'"stdout: $expected_stdout"
+    actual_desc="$actual_desc"$'\n'"stdout: $stdout"
     if [[ "$stdout" != "$expected_stdout" ]]; then
       failed=1
     fi
   fi
 
   if $check_stderr; then
-    expected_desc+=$'\n'"stderr: $expected_stderr"
-    actual_desc+=$'\n'"stderr: $stderr"
+    expected_desc="$expected_desc"$'\n'"stderr: $expected_stderr"
+    actual_desc="$actual_desc"$'\n'"stderr: $stderr"
     if [[ "$stderr" != "$expected_stderr" ]]; then
       failed=1
     fi
@@ -408,7 +431,7 @@ function assert_exec() {
 }
 
 function assert_exit_code() {
-  local actual_exit_code=${3-"$?"}  # Capture $? before guard check
+  local actual_exit_code=${3-"$?"} # Capture $? before guard check
   bashunit::assert::should_skip && return 0
 
   local expected_exit_code="$1"
@@ -427,7 +450,7 @@ function assert_exit_code() {
 }
 
 function assert_successful_code() {
-  local actual_exit_code=${3-"$?"}  # Capture $? before guard check
+  local actual_exit_code=${3-"$?"} # Capture $? before guard check
   bashunit::assert::should_skip && return 0
 
   local expected_exit_code=0
@@ -447,7 +470,7 @@ function assert_successful_code() {
 }
 
 function assert_unsuccessful_code() {
-  local actual_exit_code=${3-"$?"}  # Capture $? before guard check
+  local actual_exit_code=${3-"$?"} # Capture $? before guard check
   bashunit::assert::should_skip && return 0
 
   if [[ "$actual_exit_code" -eq 0 ]]; then
@@ -464,7 +487,7 @@ function assert_unsuccessful_code() {
 }
 
 function assert_general_error() {
-  local actual_exit_code=${3-"$?"}  # Capture $? before guard check
+  local actual_exit_code=${3-"$?"} # Capture $? before guard check
   bashunit::assert::should_skip && return 0
 
   local expected_exit_code=1
@@ -484,7 +507,7 @@ function assert_general_error() {
 }
 
 function assert_command_not_found() {
-  local actual_exit_code=${3-"$?"}  # Capture $? before guard check
+  local actual_exit_code=${3-"$?"} # Capture $? before guard check
   bashunit::assert::should_skip && return 0
 
   local expected_exit_code=127
@@ -507,7 +530,8 @@ function assert_string_starts_with() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
@@ -547,7 +571,8 @@ function assert_string_ends_with() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
@@ -568,7 +593,8 @@ function assert_string_not_ends_with() {
   bashunit::assert::should_skip && return 0
 
   local expected="$1"
-  local actual_arr=("${@:2}")
+  local -a actual_arr
+  actual_arr=("${@:2}")
   local actual
   actual=$(printf '%s\n' "${actual_arr[@]}")
 
@@ -663,11 +689,13 @@ function assert_greater_or_equal_than() {
 
 function assert_line_count() {
   bashunit::assert::should_skip && return 0
+  local IFS=$' \t\n'
 
   local expected="$1"
-  local input_arr=("${@:2}")
+  local -a input_arr
+  input_arr=("${@:2}")
   local input_str
-  input_str=$(printf '%s\n' "${input_arr[@]}")
+  input_str=$(printf '%s\n' ${input_arr+"${input_arr[@]}"})
 
   if [ -z "$input_str" ]; then
     local actual=0
@@ -675,8 +703,8 @@ function assert_line_count() {
     local actual
     actual=$(echo "$input_str" | wc -l | tr -d '[:blank:]')
     local additional_new_lines
-    additional_new_lines=$(grep -o '\\n' <<< "$input_str" | wc -l | tr -d '[:blank:]')
-    ((actual+=additional_new_lines))
+    additional_new_lines=$(grep -o '\\n' <<<"$input_str" | wc -l | tr -d '[:blank:]')
+    actual=$((actual + additional_new_lines))
   fi
 
   if [[ "$expected" != "$actual" ]]; then
@@ -686,8 +714,8 @@ function assert_line_count() {
     label="$(bashunit::helper::normalize_test_function_name "$test_fn")"
 
     bashunit::assert::mark_failed
-    bashunit::console_results::print_failed_test "${label}" "${input_str}"\
-      "to contain number of lines equal to" "${expected}"\
+    bashunit::console_results::print_failed_test "${label}" "${input_str}" \
+      "to contain number of lines equal to" "${expected}" \
       "but found" "${actual}"
     return
   fi
diff --git a/src/assert_arrays.sh b/src/assert_arrays.sh
index 214db95a..1d116997 100644
--- a/src/assert_arrays.sh
+++ b/src/assert_arrays.sh
@@ -10,9 +10,10 @@ function assert_array_contains() {
   label="$(bashunit::helper::normalize_test_function_name "$test_fn")"
   shift
 
-  local actual=("${@}")
+  local -a actual
+  actual=("$@")
 
-  if ! [[ "${actual[*]}" == *"$expected"* ]]; then
+  if ! [[ "${actual[*]:-}" == *"$expected"* ]]; then
     bashunit::assert::mark_failed
     bashunit::console_results::print_failed_test "${label}" "${actual[*]}" "to contain" "${expected}"
     return
@@ -30,9 +31,10 @@ function assert_array_not_contains() {
   local label
   label="$(bashunit::helper::normalize_test_function_name "$test_fn")"
   shift
-  local actual=("$@")
+  local -a actual
+  actual=("$@")
 
-  if [[ "${actual[*]}" == *"$expected"* ]]; then
+  if [[ "${actual[*]:-}" == *"$expected"* ]]; then
     bashunit::assert::mark_failed
     bashunit::console_results::print_failed_test "${label}" "${actual[*]}" "to not contain" "${expected}"
     return
diff --git a/src/assert_files.sh b/src/assert_files.sh
index 3c055832..db521315 100644
--- a/src/assert_files.sh
+++ b/src/assert_files.sh
@@ -74,7 +74,7 @@ function assert_files_equals() {
   local expected="$1"
   local actual="$2"
 
-  if [[ "$(diff -u "$expected" "$actual")" != '' ]] ; then
+  if [[ "$(diff -u "$expected" "$actual")" != '' ]]; then
     local test_fn
     test_fn="$(bashunit::helper::find_test_function_name)"
     local label
@@ -82,7 +82,7 @@ function assert_files_equals() {
     bashunit::assert::mark_failed
 
     bashunit::console_results::print_failed_test "${label}" "${expected}" "Compared" "${actual}" \
-        "Diff" "$(diff -u "$expected" "$actual" | sed '1,2d')"
+      "Diff" "$(diff -u "$expected" "$actual" | sed '1,2d')"
     return
   fi
 
@@ -95,7 +95,7 @@ function assert_files_not_equals() {
   local expected="$1"
   local actual="$2"
 
-  if [[ "$(diff -u "$expected" "$actual")" == '' ]] ; then
+  if [[ "$(diff -u "$expected" "$actual")" == '' ]]; then
     local test_fn
     test_fn="$(bashunit::helper::find_test_function_name)"
     local label
@@ -103,7 +103,7 @@ function assert_files_not_equals() {
     bashunit::assert::mark_failed
 
     bashunit::console_results::print_failed_test "${label}" "${expected}" "Compared" "${actual}" \
-        "Diff" "Files are equals"
+      "Diff" "Files are equals"
     return
   fi
 
diff --git a/src/assert_snapshot.sh b/src/assert_snapshot.sh
index c24e783e..a47d14be 100644
--- a/src/assert_snapshot.sh
+++ b/src/assert_snapshot.sh
@@ -70,7 +70,7 @@ function bashunit::snapshot::initialize() {
   local path="$1"
   local content="$2"
   mkdir -p "$(dirname "$path")"
-  echo "$content" > "$path"
+  echo "$content" >"$path"
   bashunit::state::add_assertions_snapshot
 }
 
@@ -80,7 +80,7 @@ function bashunit::snapshot::compare() {
   local func_name="$3"
 
   local snapshot
-  snapshot=$(tr -d '\r' < "$snapshot_path")
+  snapshot=$(tr -d '\r' <"$snapshot_path")
 
   if ! bashunit::snapshot::match_with_placeholder "$actual" "$snapshot"; then
     local label=$(bashunit::helper::normalize_test_function_name "$func_name")
diff --git a/src/benchmark.sh b/src/benchmark.sh
index 1abd4fcc..92a509bd 100644
--- a/src/benchmark.sh
+++ b/src/benchmark.sh
@@ -16,22 +16,34 @@ function bashunit::benchmark::parse_annotations() {
   local annotation
   annotation=$(awk "/function[[:space:]]+${fn_name}[[:space:]]*\(/ {print prev; exit} {prev=\$0}" "$script")
 
-  if [[ $annotation =~ @revs=([0-9]+) ]]; then
-    revs="${BASH_REMATCH[1]}"
-  elif [[ $annotation =~ @revolutions=([0-9]+) ]]; then
+  local _re='@revs=([0-9]+)'
+  if [[ "$annotation" =~ $_re ]]; then
     revs="${BASH_REMATCH[1]}"
+  else
+    _re='@revolutions=([0-9]+)'
+    if [[ "$annotation" =~ $_re ]]; then
+      revs="${BASH_REMATCH[1]}"
+    fi
   fi
 
-  if [[ $annotation =~ @its=([0-9]+) ]]; then
-    its="${BASH_REMATCH[1]}"
-  elif [[ $annotation =~ @iterations=([0-9]+) ]]; then
+  _re='@its=([0-9]+)'
+  if [[ "$annotation" =~ $_re ]]; then
     its="${BASH_REMATCH[1]}"
+  else
+    _re='@iterations=([0-9]+)'
+    if [[ "$annotation" =~ $_re ]]; then
+      its="${BASH_REMATCH[1]}"
+    fi
   fi
 
-  if [[ $annotation =~ @max_ms=([0-9.]+) ]]; then
-    max_ms="${BASH_REMATCH[1]}"
-  elif [[ $annotation =~ @max_ms=([0-9.]+) ]]; then
+  _re='@max_ms=([0-9.]+)'
+  if [[ "$annotation" =~ $_re ]]; then
     max_ms="${BASH_REMATCH[1]}"
+  else
+    _re='@max_ms=([0-9.]+)'
+    if [[ "$annotation" =~ $_re ]]; then
+      max_ms="${BASH_REMATCH[1]}"
+    fi
   fi
 
   if [[ -n "$max_ms" ]]; then
@@ -42,11 +54,11 @@ function bashunit::benchmark::parse_annotations() {
 }
 
 function bashunit::benchmark::add_result() {
-  _BASHUNIT_BENCH_NAMES+=("$1")
-  _BASHUNIT_BENCH_REVS+=("$2")
-  _BASHUNIT_BENCH_ITS+=("$3")
-  _BASHUNIT_BENCH_AVERAGES+=("$4")
-  _BASHUNIT_BENCH_MAX_MILLIS+=("$5")
+  _BASHUNIT_BENCH_NAMES[${#_BASHUNIT_BENCH_NAMES[@]}]="$1"
+  _BASHUNIT_BENCH_REVS[${#_BASHUNIT_BENCH_REVS[@]}]="$2"
+  _BASHUNIT_BENCH_ITS[${#_BASHUNIT_BENCH_ITS[@]}]="$3"
+  _BASHUNIT_BENCH_AVERAGES[${#_BASHUNIT_BENCH_AVERAGES[@]}]="$4"
+  _BASHUNIT_BENCH_MAX_MILLIS[${#_BASHUNIT_BENCH_MAX_MILLIS[@]}]="$5"
 }
 
 # shellcheck disable=SC2155
@@ -55,19 +67,23 @@ function bashunit::benchmark::run_function() {
   local revs=$2
   local its=$3
   local max_ms=$4
-  local durations=()
+  local IFS=$' \t\n'
+  local -a durations=()
+  local durations_count=0
+  local i r
 
-  for ((i=1; i<=its; i++)); do
+  for ((i = 1; i <= its; i++)); do
     local start_time=$(bashunit::clock::now)
     (
-      for ((r=1; r<=revs; r++)); do
+      for ((r = 1; r <= revs; r++)); do
         "$fn_name" >/dev/null 2>&1
       done
     )
     local end_time=$(bashunit::clock::now)
     local dur_ns=$(bashunit::math::calculate "($end_time - $start_time)")
     local dur_ms=$(bashunit::math::calculate "$dur_ns / 1000000")
-    durations+=("$dur_ms")
+    durations[durations_count]="$dur_ms"
+    durations_count=$((durations_count + 1))
 
     if bashunit::env::is_bench_mode_enabled; then
       local label="$(bashunit::helper::normalize_test_function_name "$fn_name")"
@@ -77,7 +93,8 @@ function bashunit::benchmark::run_function() {
   done
 
   local sum=0
-  for d in "${durations[@]}"; do
+  local d
+  for d in "${durations[@]+"${durations[@]}"}"; do
     sum=$(bashunit::math::calculate "$sum + $d")
   done
   local avg=$(bashunit::math::calculate "$sum / ${#durations[@]}")
@@ -89,7 +106,7 @@ function bashunit::benchmark::print_results() {
     return
   fi
 
-  if (( ${#_BASHUNIT_BENCH_NAMES[@]} == 0 )); then
+  if ((${#_BASHUNIT_BENCH_NAMES[@]} == 0)); then
     return
   fi
 
@@ -101,8 +118,10 @@ function bashunit::benchmark::print_results() {
   bashunit::print_line 80 "="
   printf "\n"
 
+  local IFS=$' \t\n'
   local has_threshold=false
-  for val in "${_BASHUNIT_BENCH_MAX_MILLIS[@]}"; do
+  local val
+  for val in "${_BASHUNIT_BENCH_MAX_MILLIS[@]+"${_BASHUNIT_BENCH_MAX_MILLIS[@]}"}"; do
     if [[ -n "$val" ]]; then
       has_threshold=true
       break
@@ -115,12 +134,13 @@ function bashunit::benchmark::print_results() {
     printf '%-40s %6s %6s %10s\n' "Name" "Revs" "Its" "Avg(ms)"
   fi
 
+  local i
   for i in "${!_BASHUNIT_BENCH_NAMES[@]}"; do
-    local name="${_BASHUNIT_BENCH_NAMES[$i]}"
-    local revs="${_BASHUNIT_BENCH_REVS[$i]}"
-    local its="${_BASHUNIT_BENCH_ITS[$i]}"
-    local avg="${_BASHUNIT_BENCH_AVERAGES[$i]}"
-    local max_ms="${_BASHUNIT_BENCH_MAX_MILLIS[$i]}"
+    local name="${_BASHUNIT_BENCH_NAMES[$i]:-}"
+    local revs="${_BASHUNIT_BENCH_REVS[$i]:-}"
+    local its="${_BASHUNIT_BENCH_ITS[$i]:-}"
+    local avg="${_BASHUNIT_BENCH_AVERAGES[$i]:-}"
+    local max_ms="${_BASHUNIT_BENCH_MAX_MILLIS[$i]:-}"
 
     if [[ -z "$max_ms" ]]; then
       printf '%-40s %6s %6s %10s\n' "$name" "$revs" "$its" "$avg"
@@ -129,13 +149,15 @@ function bashunit::benchmark::print_results() {
 
     if [[ "$avg" -le "$max_ms" ]]; then
       local raw="≤ ${max_ms}"
-      printf -v padded "%14s" "$raw"
+      local padded
+      padded=$(printf "%14s" "$raw")
       printf '%-40s %6s %6s %10s %12s\n' "$name" "$revs" "$its" "$avg" "$padded"
       continue
     fi
 
     local raw="> ${max_ms}"
-    printf -v padded "%12s" "$raw"
+    local padded
+    padded=$(printf "%12s" "$raw")
     printf '%-40s %6s %6s %10s %s%s%s\n' \
       "$name" "$revs" "$its" "$avg" \
       "$_BASHUNIT_COLOR_FAILED" "$padded" "${_BASHUNIT_COLOR_DEFAULT}"
diff --git a/src/check_os.sh b/src/check_os.sh
index 8ff2d5dd..6b8e126a 100644
--- a/src/check_os.sh
+++ b/src/check_os.sh
@@ -27,11 +27,11 @@ function bashunit::check_os::init() {
 }
 
 function bashunit::check_os::is_ubuntu() {
-  command -v apt > /dev/null
+  command -v apt >/dev/null
 }
 
 function bashunit::check_os::is_alpine() {
-  command -v apk > /dev/null
+  command -v apk >/dev/null
 }
 
 function bashunit::check_os::is_nixos() {
@@ -49,12 +49,12 @@ function bashunit::check_os::is_macos() {
 
 function bashunit::check_os::is_windows() {
   case "$(uname)" in
-    *MINGW*|*MSYS*|*CYGWIN*)
-      return 0
-      ;;
-    *)
-      return 1
-      ;;
+  *MINGW* | *MSYS* | *CYGWIN*)
+    return 0
+    ;;
+  *)
+    return 1
+    ;;
   esac
 }
 
@@ -62,12 +62,12 @@ function bashunit::check_os::is_busybox() {
 
   case "$_BASHUNIT_DISTRO" in
 
-    "Alpine")
-        return 0
-        ;;
-    *)
-      return 1
-      ;;
+  "Alpine")
+    return 0
+    ;;
+  *)
+    return 1
+    ;;
   esac
 }
 
diff --git a/src/clock.sh b/src/clock.sh
index 2ba3509e..d7978559 100644
--- a/src/clock.sh
+++ b/src/clock.sh
@@ -4,55 +4,65 @@ _BASHUNIT_CLOCK_NOW_IMPL=""
 
 function bashunit::clock::_choose_impl() {
   local shell_time
-  local attempts=()
+  # Use explicit indices for Bash 3.0 compatibility (empty array access fails with set -u)
+  local attempts_count=0
+  local attempts
 
   # 1. Try Perl with Time::HiRes
-  attempts+=("Perl")
+  attempts[attempts_count]="Perl"
+  attempts_count=$((attempts_count + 1))
   if bashunit::dependencies::has_perl && perl -MTime::HiRes -e "" &>/dev/null; then
     _BASHUNIT_CLOCK_NOW_IMPL="perl"
     return 0
   fi
 
   # 2. Try Python 3 with time module
-  attempts+=("Python")
+  attempts[attempts_count]="Python"
+  attempts_count=$((attempts_count + 1))
   if bashunit::dependencies::has_python; then
     _BASHUNIT_CLOCK_NOW_IMPL="python"
     return 0
   fi
 
   # 3. Try Node.js
-  attempts+=("Node")
+  attempts[attempts_count]="Node"
+  attempts_count=$((attempts_count + 1))
   if bashunit::dependencies::has_node; then
     _BASHUNIT_CLOCK_NOW_IMPL="node"
     return 0
   fi
   # 4. Windows fallback with PowerShell
-  attempts+=("PowerShell")
+  attempts[attempts_count]="PowerShell"
+  attempts_count=$((attempts_count + 1))
   if bashunit::check_os::is_windows && bashunit::dependencies::has_powershell; then
     _BASHUNIT_CLOCK_NOW_IMPL="powershell"
     return 0
   fi
 
   # 5. Unix fallback using `date +%s%N` (if not macOS or Alpine)
-  attempts+=("date")
+  attempts[attempts_count]="date"
+  attempts_count=$((attempts_count + 1))
   if ! bashunit::check_os::is_macos && ! bashunit::check_os::is_alpine; then
     local result
     result=$(date +%s%N 2>/dev/null)
-    if [[ "$result" != *N && "$result" =~ ^[0-9]+$ ]]; then
+    local _re='^[0-9]+$'
+    if [[ "$result" != *N ]] && [[ "$result" =~ $_re ]]; then
       _BASHUNIT_CLOCK_NOW_IMPL="date"
       return 0
     fi
   fi
 
   # 6. Try using native shell EPOCHREALTIME (if available)
-  attempts+=("EPOCHREALTIME")
+  attempts[attempts_count]="EPOCHREALTIME"
+  attempts_count=$((attempts_count + 1))
   if shell_time="$(bashunit::clock::shell_time)"; then
     _BASHUNIT_CLOCK_NOW_IMPL="shell"
     return 0
   fi
 
   # 7. Very last fallback: seconds resolution only
-  attempts[${#attempts[@]}]="date-seconds"
+  attempts[attempts_count]="date-seconds"
+  attempts_count=$((attempts_count + 1))
   if date +%s &>/dev/null; then
     _BASHUNIT_CLOCK_NOW_IMPL="date-seconds"
     return 0
@@ -70,46 +80,46 @@ function bashunit::clock::now() {
   fi
 
   case "$_BASHUNIT_CLOCK_NOW_IMPL" in
-    perl)
-      perl -MTime::HiRes -e 'printf("%.0f\n", Time::HiRes::time() * 1000000000)'
-      ;;
-    python)
-      python - <<'EOF'
+  perl)
+    perl -MTime::HiRes -e 'printf("%.0f\n", Time::HiRes::time() * 1000000000)'
+    ;;
+  python)
+    python - <<'EOF'
 import time, sys
 sys.stdout.write(str(int(time.time() * 1000000000)))
 EOF
-      ;;
-    node)
-      node -e 'process.stdout.write((BigInt(Date.now()) * 1000000n).toString())'
-      ;;
-    powershell)
-      powershell -Command "\
+    ;;
+  node)
+    node -e 'process.stdout.write((BigInt(Date.now()) * 1000000n).toString())'
+    ;;
+  powershell)
+    powershell -Command "\
         \$unixEpoch = [DateTime]'1970-01-01 00:00:00';\
         \$now = [DateTime]::UtcNow;\
         \$ticksSinceEpoch = (\$now - \$unixEpoch).Ticks;\
         \$nanosecondsSinceEpoch = \$ticksSinceEpoch * 100;\
         Write-Output \$nanosecondsSinceEpoch\
       "
-      ;;
-    date)
-      date +%s%N
-      ;;
-    date-seconds)
-      local seconds
-      seconds=$(date +%s)
-      bashunit::math::calculate "$seconds * 1000000000"
-      ;;
-    shell)
-      # shellcheck disable=SC2155
-      local shell_time="$(bashunit::clock::shell_time)"
-      local seconds="${shell_time%%.*}"
-      local microseconds="${shell_time#*.}"
-      bashunit::math::calculate "($seconds * 1000000000) + ($microseconds * 1000)"
-      ;;
-    *)
-      bashunit::clock::_choose_impl || return 1
-      bashunit::clock::now
-      ;;
+    ;;
+  date)
+    date +%s%N
+    ;;
+  date-seconds)
+    local seconds
+    seconds=$(date +%s)
+    bashunit::math::calculate "$seconds * 1000000000"
+    ;;
+  shell)
+    # shellcheck disable=SC2155
+    local shell_time="$(bashunit::clock::shell_time)"
+    local seconds="${shell_time%%.*}"
+    local microseconds="${shell_time#*.}"
+    bashunit::math::calculate "($seconds * 1000000000) + ($microseconds * 1000)"
+    ;;
+  *)
+    bashunit::clock::_choose_impl || return 1
+    bashunit::clock::now
+    ;;
   esac
 }
 
diff --git a/src/colors.sh b/src/colors.sh
index 71ed9845..3ce77abc 100644
--- a/src/colors.sh
+++ b/src/colors.sh
@@ -10,6 +10,7 @@ bashunit::sgr() {
   local codes=${1:-0}
   shift
 
+  local c
   for c in "$@"; do
     codes="$codes;$c"
   done
diff --git a/src/console_header.sh b/src/console_header.sh
index cc486935..2258b427 100644
--- a/src/console_header.sh
+++ b/src/console_header.sh
@@ -2,39 +2,39 @@
 
 function bashunit::console_header::print_version_with_env() {
   local filter=${1:-}
-  local files=("${@:2}")
+  shift || true
 
   if ! bashunit::env::is_show_header_enabled; then
     return
   fi
 
-  bashunit::console_header::print_version "$filter" "${files[@]}"
+  bashunit::console_header::print_version "$filter" "$@"
 
   if bashunit::env::is_dev_mode_enabled; then
-    printf "%sDev log:%s %s\n" "${_BASHUNIT_COLOR_INCOMPLETE}" "${_BASHUNIT_COLOR_DEFAULT}" "$BASHUNIT_DEV_LOG"
+    printf "%sDev log:%s %s\n" \
+      "${_BASHUNIT_COLOR_INCOMPLETE}" "${_BASHUNIT_COLOR_DEFAULT}" "$BASHUNIT_DEV_LOG"
   fi
 }
 
 function bashunit::console_header::print_version() {
   local filter=${1:-}
-  if [[ -n "$filter" ]]; then
-   shift
-  fi
+  shift || true
 
-  local files=("$@")
+  # Bash 3.0 compatible: check argument count after shift
+  local files_count=$#
   local total_tests
-  if [[ ${#files[@]} -eq 0 ]]; then
+  if [[ "$files_count" -eq 0 ]]; then
     total_tests=0
   elif bashunit::parallel::is_enabled && bashunit::env::is_simple_output_enabled; then
     # Skip counting in parallel+simple mode for faster startup
     total_tests=0
   else
-    total_tests=$(bashunit::helper::find_total_tests "$filter" "${files[@]}")
+    total_tests=$(bashunit::helper::find_total_tests "$filter" "$@")
   fi
 
   if bashunit::env::is_header_ascii_art_enabled; then
     cat <<EOF
- _               _                   _
+_               _                   _
 | |__   __ _ ___| |__  __ __ ____ (_) |_
 | '_ \ / _' / __| '_ \| | | | '_ \| | __|
 | |_) | (_| \__ \ | | | |_| | | | | | |_
@@ -52,14 +52,14 @@ EOF
     printf "%s%sbashunit%s - %s\n" \
       "$_BASHUNIT_COLOR_BOLD" "$_BASHUNIT_COLOR_PASSED" "$_BASHUNIT_COLOR_DEFAULT" "$BASHUNIT_VERSION"
   else
-    printf "${_BASHUNIT_COLOR_BOLD}${_BASHUNIT_COLOR_PASSED}bashunit${_BASHUNIT_COLOR_DEFAULT} - %s | Tests: %s\n"\
-      "$BASHUNIT_VERSION"\
-      "$total_tests"
+    printf "%s%sbashunit%s - %s | Tests: %s\n" \
+      "${_BASHUNIT_COLOR_BOLD}" "${_BASHUNIT_COLOR_PASSED}" "${_BASHUNIT_COLOR_DEFAULT}" \
+      "$BASHUNIT_VERSION" "$total_tests"
   fi
 }
 
 function bashunit::console_header::print_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit <command> [arguments] [options]
 
 Commands:
@@ -90,16 +90,16 @@ EOF
 }
 
 function bashunit::console_header::print_test_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit test [path] [options]
-       bashunit [path] [options]
+  bashunit [path] [options]
 
 Run test files. If no path is provided, searches for tests in BASHUNIT_DEFAULT_PATH.
 
 Arguments:
   path                        File or directory containing tests
-                              - Directories: runs all '*test.sh' files
-                              - Wildcards: supported to match multiple files
+    - Directories: runs all '*test.sh' files
+    - Wildcards: supported to match multiple files
 
 Options:
   -a, --assert <fn> <args>    Run a standalone assert function (deprecated: use 'bashunit assert')
@@ -147,7 +147,7 @@ EOF
 }
 
 function bashunit::console_header::print_bench_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit bench [path] [options]
 
 Run benchmark files. Searches for '*bench.sh' files.
@@ -174,23 +174,23 @@ EOF
 }
 
 function bashunit::console_header::print_doc_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit doc [filter]
 
 Display documentation for assertion functions.
 
 Arguments:
-  filter                      Optional filter to show only matching assertions
+filter                      Optional filter to show only matching assertions
 
 Examples:
-  bashunit doc                Show all assertions
-  bashunit doc equals         Show assertions containing 'equals'
-  bashunit doc file           Show file-related assertions
+bashunit doc                Show all assertions
+bashunit doc equals         Show assertions containing 'equals'
+bashunit doc file           Show file-related assertions
 EOF
 }
 
 function bashunit::console_header::print_init_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit init [directory]
 
 Initialize a new test directory with sample files.
@@ -209,7 +209,7 @@ EOF
 }
 
 function bashunit::console_header::print_learn_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit learn
 
 Start the interactive learning tutorial.
@@ -231,7 +231,7 @@ EOF
 }
 
 function bashunit::console_header::print_upgrade_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit upgrade
 
 Upgrade bashunit to the latest version.
@@ -241,9 +241,9 @@ EOF
 }
 
 function bashunit::console_header::print_assert_help() {
-    cat <<EOF
+  cat <<EOF
 Usage: bashunit assert <function> [args...]
-       bashunit assert "<command>" <assertion1> <arg1> [<assertion2> <arg2>...]
+  bashunit assert "<command>" <assertion1> <arg1> [<assertion2> <arg2>...]
 
 Run standalone assertion(s) without creating a test file.
 
@@ -264,7 +264,7 @@ Arguments:
   arg                         Expected value for the assertion
 
 Note: You can also use 'bashunit test --assert <fn> <args>' (deprecated).
-      The 'bashunit assert' subcommand is the recommended approach.
+  The 'bashunit assert' subcommand is the recommended approach.
 
 More info: https://bashunit.typeddevs.com/standalone
 EOF
diff --git a/src/console_results.sh b/src/console_results.sh
index 143ccbfd..ab96cd26 100644
--- a/src/console_results.sh
+++ b/src/console_results.sh
@@ -29,18 +29,18 @@ function bashunit::console_results::render_result() {
   local assertions_failed=$_BASHUNIT_ASSERTIONS_FAILED
 
   local total_tests=0
-  ((total_tests += tests_passed)) || true
-  ((total_tests += tests_skipped)) || true
-  ((total_tests += tests_incomplete)) || true
-  ((total_tests += tests_snapshot)) || true
-  ((total_tests += tests_failed)) || true
+  total_tests=$((total_tests + tests_passed))
+  total_tests=$((total_tests + tests_skipped))
+  total_tests=$((total_tests + tests_incomplete))
+  total_tests=$((total_tests + tests_snapshot))
+  total_tests=$((total_tests + tests_failed))
 
   local total_assertions=0
-  ((total_assertions += assertions_passed)) || true
-  ((total_assertions += assertions_skipped)) || true
-  ((total_assertions += assertions_incomplete)) || true
-  ((total_assertions += assertions_snapshot)) || true
-  ((total_assertions += assertions_failed)) || true
+  total_assertions=$((total_assertions + assertions_passed))
+  total_assertions=$((total_assertions + assertions_skipped))
+  total_assertions=$((total_assertions + assertions_incomplete))
+  total_assertions=$((total_assertions + assertions_snapshot))
+  total_assertions=$((total_assertions + assertions_failed))
 
   printf "%sTests:     %s" "$_BASHUNIT_COLOR_FAINT" "$_BASHUNIT_COLOR_DEFAULT"
   if [[ "$tests_passed" -gt 0 ]] || [[ "$assertions_passed" -gt 0 ]]; then
@@ -62,7 +62,7 @@ function bashunit::console_results::render_result() {
 
   printf "%sAssertions:%s" "$_BASHUNIT_COLOR_FAINT" "$_BASHUNIT_COLOR_DEFAULT"
   if [[ "$tests_passed" -gt 0 ]] || [[ "$assertions_passed" -gt 0 ]]; then
-      printf " %s%s passed%s," "$_BASHUNIT_COLOR_PASSED" "$assertions_passed" "$_BASHUNIT_COLOR_DEFAULT"
+    printf " %s%s passed%s," "$_BASHUNIT_COLOR_PASSED" "$assertions_passed" "$_BASHUNIT_COLOR_DEFAULT"
   fi
   if [[ "$tests_skipped" -gt 0 ]] || [[ "$assertions_skipped" -gt 0 ]]; then
     printf " %s%s skipped%s," "$_BASHUNIT_COLOR_SKIPPED" "$assertions_skipped" "$_BASHUNIT_COLOR_DEFAULT"
@@ -126,11 +126,11 @@ function bashunit::console_results::print_execution_time() {
     return
   fi
 
-  local time_in_seconds=$(( time / 1000 ))
+  local time_in_seconds=$((time / 1000))
 
   if [[ "$time_in_seconds" -ge 60 ]]; then
-    local minutes=$(( time_in_seconds / 60 ))
-    local seconds=$(( time_in_seconds % 60 ))
+    local minutes=$((time_in_seconds / 60))
+    local seconds=$((time_in_seconds % 60))
     printf "${_BASHUNIT_COLOR_BOLD}%s${_BASHUNIT_COLOR_DEFAULT}\n" \
       "Time taken: ${minutes}m ${seconds}s"
     return
@@ -147,9 +147,9 @@ function bashunit::console_results::format_duration() {
   local duration_ms="$1"
 
   if [[ "$duration_ms" -ge 60000 ]]; then
-    local time_in_seconds=$(( duration_ms / 1000 ))
-    local minutes=$(( time_in_seconds / 60 ))
-    local seconds=$(( time_in_seconds % 60 ))
+    local time_in_seconds=$((duration_ms / 1000))
+    local minutes=$((time_in_seconds / 60))
+    local seconds=$((time_in_seconds % 60))
     echo "${minutes}m ${seconds}s"
   elif [[ "$duration_ms" -ge 1000 ]]; then
     local formatted_seconds
@@ -201,6 +201,7 @@ function bashunit::console_results::print_successful_test() {
     line=$(printf "%s✓ Passed%s: %s" "$_BASHUNIT_COLOR_PASSED" "$_BASHUNIT_COLOR_DEFAULT" "$test_name")
   else
     local quoted_args=""
+    local arg
     for arg in "$@"; do
       if [[ -z "$quoted_args" ]]; then
         quoted_args="'$arg'"
@@ -216,9 +217,9 @@ function bashunit::console_results::print_successful_test() {
   if bashunit::env::is_show_execution_time_enabled; then
     local time_display
     if [[ "$duration" -ge 60000 ]]; then
-      local time_in_seconds=$(( duration / 1000 ))
-      local minutes=$(( time_in_seconds / 60 ))
-      local seconds=$(( time_in_seconds % 60 ))
+      local time_in_seconds=$((duration / 1000))
+      local minutes=$((time_in_seconds / 60))
+      local seconds=$((time_in_seconds % 60))
       time_display="${minutes}m ${seconds}s"
     elif [[ "$duration" -ge 1000 ]]; then
       local formatted_seconds
@@ -240,7 +241,8 @@ function bashunit::console_results::print_failure_message() {
   local line
   line="$(printf "\
 ${_BASHUNIT_COLOR_FAILED}✗ Failed${_BASHUNIT_COLOR_DEFAULT}: %s
-    ${_BASHUNIT_COLOR_FAINT}Message:${_BASHUNIT_COLOR_DEFAULT} ${_BASHUNIT_COLOR_BOLD}'%s'${_BASHUNIT_COLOR_DEFAULT}\n"\
+    ${_BASHUNIT_COLOR_FAINT}Message:${_BASHUNIT_COLOR_DEFAULT} \
+${_BASHUNIT_COLOR_BOLD}'%s'${_BASHUNIT_COLOR_DEFAULT}\n" \
     "${test_name}" "${failure_message}")"
 
   bashunit::state::print_line "failure" "$line"
@@ -262,16 +264,15 @@ ${_BASHUNIT_COLOR_FAILED}✗ Failed${_BASHUNIT_COLOR_DEFAULT}: %s
     "${function_name}" "${expected}" "${failure_condition_message}" "${actual}")"
 
   if [ -n "$extra_key" ]; then
-    line+="$(printf "\
+    line="$line$(printf "\
 
     ${_BASHUNIT_COLOR_FAINT}%s${_BASHUNIT_COLOR_DEFAULT} ${_BASHUNIT_COLOR_BOLD}'%s'${_BASHUNIT_COLOR_DEFAULT}\n" \
-    "${extra_key}" "${extra_value}")"
+      "${extra_key}" "${extra_value}")"
   fi
 
   bashunit::state::print_line "failed" "$line"
 }
 
-
 function bashunit::console_results::print_failed_snapshot_test() {
   local function_name=$1
   local snapshot_file=$2
@@ -283,14 +284,14 @@ function bashunit::console_results::print_failed_snapshot_test() {
 
   if bashunit::dependencies::has_git; then
     local actual_file="${snapshot_file}.tmp"
-    echo "$actual_content" > "$actual_file"
+    echo "$actual_content" >"$actual_file"
 
     local git_diff_output
     git_diff_output="$(git diff --no-index --word-diff --color=always \
-      "$snapshot_file" "$actual_file" 2>/dev/null \
-        | tail -n +6 | sed "s/^/    /")"
+      "$snapshot_file" "$actual_file" 2>/dev/null |
+      tail -n +6 | sed "s/^/    /")"
 
-    line+="$git_diff_output"
+    line="$line$git_diff_output"
     rm "$actual_file"
   fi
 
@@ -305,7 +306,7 @@ function bashunit::console_results::print_skipped_test() {
   line="$(printf "${_BASHUNIT_COLOR_SKIPPED}↷ Skipped${_BASHUNIT_COLOR_DEFAULT}: %s\n" "${function_name}")"
 
   if [[ -n "$reason" ]]; then
-    line+="$(printf "${_BASHUNIT_COLOR_FAINT}    %s${_BASHUNIT_COLOR_DEFAULT}\n" "${reason}")"
+    line="$line$(printf "${_BASHUNIT_COLOR_FAINT}    %s${_BASHUNIT_COLOR_DEFAULT}\n" "${reason}")"
   fi
 
   bashunit::state::print_line "skipped" "$line"
@@ -319,7 +320,7 @@ function bashunit::console_results::print_incomplete_test() {
   line="$(printf "${_BASHUNIT_COLOR_INCOMPLETE}✒ Incomplete${_BASHUNIT_COLOR_DEFAULT}: %s\n" "${function_name}")"
 
   if [[ -n "$pending" ]]; then
-    line+="$(printf "${_BASHUNIT_COLOR_FAINT}    %s${_BASHUNIT_COLOR_DEFAULT}\n" "${pending}")"
+    line="$line$(printf "${_BASHUNIT_COLOR_FAINT}    %s${_BASHUNIT_COLOR_DEFAULT}\n" "${pending}")"
   fi
 
   bashunit::state::print_line "incomplete" "$line"
@@ -349,10 +350,11 @@ function bashunit::console_results::print_error_test() {
     ${_BASHUNIT_COLOR_FAINT}%s${_BASHUNIT_COLOR_DEFAULT}\n" "${test_name}" "${error}")"
 
   if [[ -n "$raw_output" ]] && bashunit::env::is_show_output_on_failure_enabled; then
-    line+="$(printf "    %sOutput:%s\n" "${_BASHUNIT_COLOR_FAINT}" "${_BASHUNIT_COLOR_DEFAULT}")"
+    line="$line$(printf "    %sOutput:%s\n" "${_BASHUNIT_COLOR_FAINT}" "${_BASHUNIT_COLOR_DEFAULT}")"
+    local output_line
     while IFS= read -r output_line; do
-      line+="$(printf "      %s\n" "$output_line")"
-    done <<< "$raw_output"
+      line="$line$(printf "      %s\n" "$output_line")"
+    done <<<"$raw_output"
   fi
 
   bashunit::state::print_line "error" "$line"
@@ -395,7 +397,7 @@ function bashunit::console_results::print_skipped_tests_and_reset() {
       echo -e "${_BASHUNIT_COLOR_BOLD}There were $total_skipped skipped tests:${_BASHUNIT_COLOR_DEFAULT}\n"
     fi
 
-    tr -d '\r' < "$SKIPPED_OUTPUT_PATH" | sed '/^[[:space:]]*$/d' | sed 's/^/|/'
+    tr -d '\r' <"$SKIPPED_OUTPUT_PATH" | sed '/^[[:space:]]*$/d' | sed 's/^/|/'
     rm "$SKIPPED_OUTPUT_PATH"
 
     echo ""
@@ -417,7 +419,7 @@ function bashunit::console_results::print_incomplete_tests_and_reset() {
       echo -e "${_BASHUNIT_COLOR_BOLD}There were $total_incomplete incomplete tests:${_BASHUNIT_COLOR_DEFAULT}\n"
     fi
 
-    tr -d '\r' < "$INCOMPLETE_OUTPUT_PATH" | sed '/^[[:space:]]*$/d' | sed 's/^/|/'
+    tr -d '\r' <"$INCOMPLETE_OUTPUT_PATH" | sed '/^[[:space:]]*$/d' | sed 's/^/|/'
     rm "$INCOMPLETE_OUTPUT_PATH"
 
     echo ""
diff --git a/src/coverage.sh b/src/coverage.sh
index 34f96cd8..ddab9226 100644
--- a/src/coverage.sh
+++ b/src/coverage.sh
@@ -6,7 +6,7 @@
 _BASHUNIT_COVERAGE_DATA_FILE="${_BASHUNIT_COVERAGE_DATA_FILE:-}"
 _BASHUNIT_COVERAGE_TRACKED_FILES="${_BASHUNIT_COVERAGE_TRACKED_FILES:-}"
 
-# Simple file-based cache for tracked files (Bash 3.2 compatible)
+# Simple file-based cache for tracked files (Bash 3.0 compatible)
 # The tracked cache file stores files that have already been processed
 _BASHUNIT_COVERAGE_TRACKED_CACHE_FILE="${_BASHUNIT_COVERAGE_TRACKED_CACHE_FILE:-}"
 
@@ -20,6 +20,8 @@ function bashunit::coverage::auto_discover_paths() {
   local project_root
   project_root="$(pwd)"
   local -a discovered_paths=()
+  local discovered_paths_count=0
+  local test_file
 
   for test_file in "$@"; do
     # Extract base name: tests/unit/assert_test.sh -> assert_test.sh
@@ -29,21 +31,23 @@ function bashunit::coverage::auto_discover_paths() {
     # Remove test suffixes to get source name: assert_test.sh -> assert
     local source_name="${file_basename%_test.sh}"
     [[ "$source_name" == "$file_basename" ]] && source_name="${file_basename%Test.sh}"
-    [[ "$source_name" == "$file_basename" ]] && continue  # Not a test file pattern
+    [[ "$source_name" == "$file_basename" ]] && continue # Not a test file pattern
 
     # Find matching source files recursively
+    local found_file
     while IFS= read -r -d '' found_file; do
       # Skip test files and vendor directories
       [[ "$found_file" == *test* ]] && continue
       [[ "$found_file" == *Test* ]] && continue
       [[ "$found_file" == *vendor* ]] && continue
       [[ "$found_file" == *node_modules* ]] && continue
-      discovered_paths+=("$found_file")
+      discovered_paths[discovered_paths_count]="$found_file"
+      discovered_paths_count=$((discovered_paths_count + 1))
     done < <(find "$project_root" -name "${source_name}*.sh" -type f -print0 2>/dev/null)
   done
 
   # Return unique paths, comma-separated
-  if [[ ${#discovered_paths[@]} -gt 0 ]]; then
+  if [[ "$discovered_paths_count" -gt 0 ]]; then
     printf '%s\n' "${discovered_paths[@]}" | sort -u | tr '\n' ',' | sed 's/,$//'
   fi
 }
@@ -73,10 +77,10 @@ function bashunit::coverage::init() {
   _BASHUNIT_COVERAGE_TEST_HITS_FILE="${coverage_dir}/test_hits.dat"
 
   # Initialize empty files
-  : > "$_BASHUNIT_COVERAGE_DATA_FILE"
-  : > "$_BASHUNIT_COVERAGE_TRACKED_FILES"
-  : > "$_BASHUNIT_COVERAGE_TRACKED_CACHE_FILE"
-  : > "$_BASHUNIT_COVERAGE_TEST_HITS_FILE"
+  : >"$_BASHUNIT_COVERAGE_DATA_FILE"
+  : >"$_BASHUNIT_COVERAGE_TRACKED_FILES"
+  : >"$_BASHUNIT_COVERAGE_TRACKED_CACHE_FILE"
+  : >"$_BASHUNIT_COVERAGE_TEST_HITS_FILE"
 
   export _BASHUNIT_COVERAGE_DATA_FILE
   export _BASHUNIT_COVERAGE_TRACKED_FILES
@@ -184,12 +188,12 @@ function bashunit::coverage::record_line() {
 
   # Record the hit (only if parent directory exists)
   if [[ -d "$(dirname "$data_file")" ]]; then
-    echo "${normalized_file}:${lineno}" >> "$data_file"
+    echo "${normalized_file}:${lineno}" >>"$data_file"
 
     # Also record which test caused this hit (if we're in a test context)
     if [[ -n "${_BASHUNIT_COVERAGE_CURRENT_TEST_FILE:-}" && -n "${_BASHUNIT_COVERAGE_CURRENT_TEST_FN:-}" ]]; then
       # Format: source_file:line|test_file:test_function
-      echo "${normalized_file}:${lineno}|${_BASHUNIT_COVERAGE_CURRENT_TEST_FILE}:${_BASHUNIT_COVERAGE_CURRENT_TEST_FN}" >> "$test_hits_file"
+      echo "${normalized_file}:${lineno}|${_BASHUNIT_COVERAGE_CURRENT_TEST_FILE}:${_BASHUNIT_COVERAGE_CURRENT_TEST_FN}" >>"$test_hits_file"
     fi
   fi
 }
@@ -203,14 +207,14 @@ function bashunit::coverage::should_track() {
   # Skip if tracked files list doesn't exist (trap inherited by child process)
   [[ -z "$_BASHUNIT_COVERAGE_TRACKED_FILES" ]] && return 1
 
-  # Check file-based cache for previous decision (Bash 3.2 compatible)
+  # Check file-based cache for previous decision (Bash 3.0 compatible)
   # Cache format: "file:0" for excluded, "file:1" for tracked
   # In parallel mode, use per-process cache to avoid race conditions
   local cache_file="$_BASHUNIT_COVERAGE_TRACKED_CACHE_FILE"
   if bashunit::parallel::is_enabled && [[ -n "$cache_file" ]]; then
     cache_file="${cache_file}.$$"
     # Initialize per-process cache if needed
-    [[ ! -f "$cache_file" ]] && [[ -d "$(dirname "$cache_file")" ]] && : > "$cache_file"
+    [[ ! -f "$cache_file" ]] && [[ -d "$(dirname "$cache_file")" ]] && : >"$cache_file"
   fi
   if [[ -n "$cache_file" && -f "$cache_file" ]]; then
     local cached_decision
@@ -233,12 +237,12 @@ function bashunit::coverage::should_track() {
   for pattern in $BASHUNIT_COVERAGE_EXCLUDE; do
     # shellcheck disable=SC2254
     case "$normalized_file" in
-      *$pattern*)
-        IFS="$old_ifs"
-        # Cache exclusion decision (use per-process cache in parallel mode)
-        [[ -n "$cache_file" && -f "$cache_file" ]] && echo "${file}:0" >> "$cache_file"
-        return 1
-        ;;
+    *$pattern*)
+      IFS="$old_ifs"
+      # Cache exclusion decision (use per-process cache in parallel mode)
+      [[ -n "$cache_file" && -f "$cache_file" ]] && echo "${file}:0" >>"$cache_file"
+      return 1
+      ;;
     esac
   done
 
@@ -263,12 +267,12 @@ function bashunit::coverage::should_track() {
 
   if [[ "$matched" == "false" ]]; then
     # Cache exclusion decision (use per-process cache in parallel mode)
-    [[ -n "$cache_file" && -f "$cache_file" ]] && echo "${file}:0" >> "$cache_file"
+    [[ -n "$cache_file" && -f "$cache_file" ]] && echo "${file}:0" >>"$cache_file"
     return 1
   fi
 
   # Cache tracking decision (use per-process cache in parallel mode)
-  [[ -n "$cache_file" && -f "$cache_file" ]] && echo "${file}:1" >> "$cache_file"
+  [[ -n "$cache_file" && -f "$cache_file" ]] && echo "${file}:1" >>"$cache_file"
 
   # Track this file for later reporting
   # In parallel mode, use a per-process file to avoid race conditions
@@ -281,7 +285,7 @@ function bashunit::coverage::should_track() {
   if [[ -d "$(dirname "$tracked_file")" ]]; then
     # Check if not already written to avoid duplicates
     if ! grep -q "^${normalized_file}$" "$tracked_file" 2>/dev/null; then
-      echo "$normalized_file" >> "$tracked_file"
+      echo "$normalized_file" >>"$tracked_file"
     fi
   fi
 
@@ -296,14 +300,14 @@ function bashunit::coverage::aggregate_parallel() {
 
   # Find and merge all per-process coverage data files
   # Use nullglob to handle case when no files match
-  local pid_files
+  local pid_files pid_file
   pid_files=$(ls -1 "${base_file}."* 2>/dev/null) || true
   if [[ -n "$pid_files" ]]; then
     while IFS= read -r pid_file; do
       [[ -f "$pid_file" ]] || continue
-      cat "$pid_file" >> "$base_file"
+      cat "$pid_file" >>"$base_file"
       rm -f "$pid_file"
-    done <<< "$pid_files"
+    done <<<"$pid_files"
   fi
 
   # Find and merge all per-process tracked files lists
@@ -311,9 +315,9 @@ function bashunit::coverage::aggregate_parallel() {
   if [[ -n "$pid_files" ]]; then
     while IFS= read -r pid_file; do
       [[ -f "$pid_file" ]] || continue
-      cat "$pid_file" >> "$tracked_base"
+      cat "$pid_file" >>"$tracked_base"
       rm -f "$pid_file"
-    done <<< "$pid_files"
+    done <<<"$pid_files"
   fi
 
   # Find and merge all per-process test hits files
@@ -322,9 +326,9 @@ function bashunit::coverage::aggregate_parallel() {
     if [[ -n "$pid_files" ]]; then
       while IFS= read -r pid_file; do
         [[ -f "$pid_file" ]] || continue
-        cat "$pid_file" >> "$test_hits_base"
+        cat "$pid_file" >>"$test_hits_base"
         rm -f "$pid_file"
-      done <<< "$pid_files"
+      done <<<"$pid_files"
     fi
   fi
 
@@ -338,7 +342,7 @@ function bashunit::coverage::aggregate_parallel() {
 # Matches: function foo() { OR foo() { OR function foo() OR foo()
 # Does NOT match single-line functions with body: function foo() { echo "hi"; }
 _BASHUNIT_COVERAGE_FUNC_PATTERN='^[[:space:]]*(function[[:space:]]+)?'
-_BASHUNIT_COVERAGE_FUNC_PATTERN+='[a-zA-Z_][a-zA-Z0-9_:]*[[:space:]]*\(\)[[:space:]]*\{?[[:space:]]*$'
+_BASHUNIT_COVERAGE_FUNC_PATTERN="${_BASHUNIT_COVERAGE_FUNC_PATTERN}"'[a-zA-Z_][a-zA-Z0-9_:]*[[:space:]]*\(\)[[:space:]]*\{?[[:space:]]*$'
 
 # Check if a line is executable (used by get_executable_lines and report_lcov)
 # Arguments: line content, line number
@@ -351,25 +355,30 @@ function bashunit::coverage::is_executable_line() {
   : "$lineno"
 
   # Skip empty lines (line with only whitespace)
-  [[ -z "${line// }" ]] && return 1
+  [[ -z "${line// /}" ]] && return 1
 
   # Skip comment-only lines (including shebang)
-  [[ "$line" =~ ^[[:space:]]*# ]] && return 1
+  local _re='^[[:space:]]*#'
+  [[ "$line" =~ $_re ]] && return 1
 
   # Skip function declaration lines (but not single-line functions with body)
   [[ "$line" =~ $_BASHUNIT_COVERAGE_FUNC_PATTERN ]] && return 1
 
   # Skip lines with only braces
-  [[ "$line" =~ ^[[:space:]]*[\{\}][[:space:]]*$ ]] && return 1
+  _re='^[[:space:]]*[\{\}][[:space:]]*$'
+  [[ "$line" =~ $_re ]] && return 1
 
   # Skip control flow keywords (then, else, fi, do, done, esac, in, ;;, ;&, ;;&)
-  [[ "$line" =~ ^[[:space:]]*(then|else|fi|do|done|esac|in|;;|;;&|;&)[[:space:]]*(#.*)?$ ]] && return 1
+  _re='^[[:space:]]*(then|else|fi|do|done|esac|in|;;|;;&|;&)[[:space:]]*(#.*)?$'
+  [[ "$line" =~ $_re ]] && return 1
 
   # Skip case patterns like "--option)" or "*)"
-  [[ "$line" =~ ^[[:space:]]*[^\)]+\)[[:space:]]*$ ]] && return 1
+  _re='^[[:space:]]*[^\)]+\)[[:space:]]*$'
+  [[ "$line" =~ $_re ]] && return 1
 
   # Skip standalone ) for arrays/subshells
-  [[ "$line" =~ ^[[:space:]]*\)[[:space:]]*(#.*)?$ ]] && return 1
+  _re='^[[:space:]]*\)[[:space:]]*(#.*)?$'
+  [[ "$line" =~ $_re ]] && return 1
 
   return 0
 }
@@ -378,11 +387,12 @@ function bashunit::coverage::get_executable_lines() {
   local file="$1"
   local count=0
   local lineno=0
+  local line
 
   while IFS= read -r line || [[ -n "$line" ]]; do
     ((lineno++))
     bashunit::coverage::is_executable_line "$line" "$lineno" && ((count++))
-  done < "$file"
+  done <"$file"
 
   echo "$count"
 }
@@ -397,7 +407,7 @@ function bashunit::coverage::get_hit_lines() {
 
   # Get unique hit line numbers
   local hit_lines
-  hit_lines=$( (grep "^${file}:" "$_BASHUNIT_COVERAGE_DATA_FILE" 2>/dev/null || true) | \
+  hit_lines=$( (grep "^${file}:" "$_BASHUNIT_COVERAGE_DATA_FILE" 2>/dev/null || true) |
     cut -d: -f2 | sort -u)
 
   if [[ -z "$hit_lines" ]]; then
@@ -444,8 +454,9 @@ function bashunit::coverage::get_all_line_hits() {
   fi
 
   # Extract all lines for this file, count occurrences of each line number
-  grep "^${file}:" "$_BASHUNIT_COVERAGE_DATA_FILE" 2>/dev/null | \
-    cut -d: -f2 | sort | uniq -c | \
+  local count lineno
+  grep "^${file}:" "$_BASHUNIT_COVERAGE_DATA_FILE" 2>/dev/null |
+    cut -d: -f2 | sort | uniq -c |
     while read -r count lineno; do
       echo "${lineno}:${count}"
     done
@@ -462,7 +473,7 @@ function bashunit::coverage::get_all_line_tests() {
 
   # Format in file: source_file:line|test_file:test_function
   # Output: lineno|test_file:test_function
-  grep "^${file}:" "$_BASHUNIT_COVERAGE_TEST_HITS_FILE" 2>/dev/null | \
+  grep "^${file}:" "$_BASHUNIT_COVERAGE_TEST_HITS_FILE" 2>/dev/null |
     sed "s|^${file}:||" | sort -u
 }
 
@@ -476,6 +487,7 @@ function bashunit::coverage::extract_functions() {
   local brace_count=0
   local current_fn=""
   local fn_start=0
+  local line
 
   while IFS= read -r line || [[ -n "$line" ]]; do
     ((lineno++))
@@ -487,10 +499,14 @@ function bashunit::coverage::extract_functions() {
       local fn_name=""
 
       # Match: function name() or function name {
-      if [[ "$line" =~ ^[[:space:]]*(function[[:space:]]+)?([a-zA-Z_][a-zA-Z0-9_:]*)[[:space:]]*\(\)[[:space:]]*\{?[[:space:]]*(#.*)?$ ]]; then
-        fn_name="${BASH_REMATCH[2]}"
-      elif [[ "$line" =~ ^[[:space:]]*(function[[:space:]]+)([a-zA-Z_][a-zA-Z0-9_:]*)[[:space:]]*\{[[:space:]]*(#.*)?$ ]]; then
+      local _re='^[[:space:]]*(function[[:space:]]+)?([a-zA-Z_][a-zA-Z0-9_:]*)[[:space:]]*\(\)[[:space:]]*\{?[[:space:]]*(#.*)?$'
+      if [[ "$line" =~ $_re ]]; then
         fn_name="${BASH_REMATCH[2]}"
+      else
+        _re='^[[:space:]]*(function[[:space:]]+)([a-zA-Z_][a-zA-Z0-9_:]*)[[:space:]]*\{[[:space:]]*(#.*)?$'
+        if [[ "$line" =~ $_re ]]; then
+          fn_name="${BASH_REMATCH[2]}"
+        fi
       fi
 
       if [[ -n "$fn_name" ]]; then
@@ -505,7 +521,8 @@ function bashunit::coverage::extract_functions() {
         brace_count=$((brace_count + ${#open_braces} - ${#close_braces}))
 
         # Single-line function
-        if [[ $brace_count -eq 0 && "$line" =~ \{ && "$line" =~ \} ]]; then
+        local _re_ob='\{' _re_cb='\}'
+        if [[ $brace_count -eq 0 ]] && [[ "$line" =~ $_re_ob ]] && [[ "$line" =~ $_re_cb ]]; then
           echo "${current_fn}:${fn_start}:${lineno}"
           in_function=0
           current_fn=""
@@ -528,7 +545,7 @@ function bashunit::coverage::extract_functions() {
         brace_count=0
       fi
     fi
-  done < "$file"
+  done <"$file"
 
   # Handle unclosed function (shouldn't happen in valid code)
   if [[ $in_function -eq 1 && -n "$current_fn" ]]; then
@@ -549,7 +566,7 @@ function bashunit::coverage::get_function_coverage() {
 
   local executable=0
   local hit=0
-  local lineno
+  local lineno=0
 
   for ((lineno = fn_start; lineno <= fn_end; lineno++)); do
     local line_content
@@ -583,8 +600,8 @@ function bashunit::coverage::get_percentage() {
     executable=$(bashunit::coverage::get_executable_lines "$file")
     hit=$(bashunit::coverage::get_hit_lines "$file")
 
-    ((total_executable += executable))
-    ((total_hit += hit))
+    total_executable=$((total_executable + executable))
+    total_hit=$((total_hit + hit))
   done < <(bashunit::coverage::get_tracked_files)
 
   bashunit::coverage::calculate_percentage "$total_hit" "$total_executable"
@@ -603,6 +620,7 @@ function bashunit::coverage::report_text() {
   echo "Coverage Report"
   echo "---------------"
 
+  local file
   while IFS= read -r file; do
     [[ -z "$file" || ! -f "$file" ]] && continue
     has_files=true
@@ -613,17 +631,17 @@ function bashunit::coverage::report_text() {
     pct=$(bashunit::coverage::calculate_percentage "$hit" "$executable")
     class=$(bashunit::coverage::get_coverage_class "$pct")
 
-    ((total_executable += executable))
-    ((total_hit += hit))
+    total_executable=$((total_executable + executable))
+    total_hit=$((total_hit + hit))
 
     # Determine color based on class
     local color="" reset=""
     if [[ "${BASHUNIT_NO_COLOR:-false}" != "true" ]]; then
       reset=$'\033[0m'
       case "$class" in
-        high)   color=$'\033[32m' ;;  # Green
-        medium) color=$'\033[33m' ;;  # Yellow
-        low)    color=$'\033[31m' ;;  # Red
+      high) color=$'\033[32m' ;;   # Green
+      medium) color=$'\033[33m' ;; # Yellow
+      low) color=$'\033[31m' ;;    # Red
       esac
     fi
 
@@ -650,9 +668,9 @@ function bashunit::coverage::report_text() {
   if [[ "${BASHUNIT_NO_COLOR:-false}" != "true" ]]; then
     reset=$'\033[0m'
     case "$total_class" in
-      high)   color=$'\033[32m' ;;
-      medium) color=$'\033[33m' ;;
-      low)    color=$'\033[31m' ;;
+    high) color=$'\033[32m' ;;
+    medium) color=$'\033[33m' ;;
+    low) color=$'\033[31m' ;;
     esac
   fi
 
@@ -686,12 +704,13 @@ function bashunit::coverage::report_lcov() {
       echo "SF:$file"
 
       local lineno=0
+      local line
       # shellcheck disable=SC2094
       while IFS= read -r line || [[ -n "$line" ]]; do
         ((lineno++))
         bashunit::coverage::is_executable_line "$line" "$lineno" || continue
         echo "DA:${lineno},$(bashunit::coverage::get_line_hits "$file" "$lineno")"
-      done < "$file"
+      done <"$file"
 
       local executable hit
       executable=$(bashunit::coverage::get_executable_lines "$file")
@@ -701,7 +720,7 @@ function bashunit::coverage::report_lcov() {
       echo "LH:$hit"
       echo "end_of_record"
     done < <(bashunit::coverage::get_tracked_files)
-  } > "$output_file"
+  } >"$output_file"
 }
 
 function bashunit::coverage::check_threshold() {
@@ -754,9 +773,12 @@ function bashunit::coverage::report_html() {
   mkdir -p "$output_dir/files"
 
   # Collect file data for index
+  local IFS=$' \t\n'
   local total_executable=0
   local total_hit=0
-  local file_data=()
+  local -a file_data=()
+  local file_data_count=0
+  local file=""
 
   while IFS= read -r file; do
     [[ -z "$file" || ! -f "$file" ]] && continue
@@ -766,14 +788,15 @@ function bashunit::coverage::report_html() {
     hit=$(bashunit::coverage::get_hit_lines "$file")
     pct=$(bashunit::coverage::calculate_percentage "$hit" "$executable")
 
-    ((total_executable += executable))
-    ((total_hit += hit))
+    total_executable=$((total_executable + executable))
+    total_hit=$((total_hit + hit))
 
     local display_file="${file#"$(pwd)"/}"
     local safe_filename
     safe_filename=$(bashunit::coverage::path_to_filename "$file")
 
-    file_data+=("$display_file|$hit|$executable|$pct|$safe_filename")
+    file_data[file_data_count]="$display_file|$hit|$executable|$pct|$safe_filename"
+    file_data_count=$((file_data_count + 1))
 
     # Generate individual file HTML
     bashunit::coverage::generate_file_html "$file" "$output_dir/files/${safe_filename}.html"
@@ -798,6 +821,8 @@ function bashunit::coverage::report_html() {
 }
 
 function bashunit::coverage::generate_index_html() {
+  # Set normal IFS for array operations throughout the function (Bash 3.0/4.3 compatible)
+  local IFS=$' \t\n'
   local output_file="$1"
   local total_hit="$2"
   local total_executable="$3"
@@ -806,13 +831,16 @@ function bashunit::coverage::generate_index_html() {
   local tests_passed="$6"
   local tests_failed="$7"
   shift 7
-  local file_data=()
-  [[ $# -gt 0 ]] && file_data=("$@")
+  # Handle array passed as arguments - Bash 3.0 compatible
+  local -a file_data=()
+  local file_count=0
+  if [[ $# -gt 0 ]]; then
+    file_data=("$@")
+    file_count=$#
+  fi
 
   # Calculate uncovered lines and file count
   local total_uncovered=$((total_executable - total_hit))
-  local file_count=0
-  [[ ${#file_data[@]} -gt 0 ]] && file_count=${#file_data[@]}
 
   # Calculate gauge stroke offset (440 is full circle circumference)
   local gauge_offset=$((440 - (440 * total_pct / 100)))
@@ -821,19 +849,25 @@ function bashunit::coverage::generate_index_html() {
   local total_class gauge_color_start gauge_color_end gauge_text_gradient
   total_class=$(bashunit::coverage::get_coverage_class "$total_pct")
   case "$total_class" in
-    high)
-      gauge_color_start="#10b981"; gauge_color_end="#34d399"
-      gauge_text_gradient="linear-gradient(135deg, #10b981 0%, #34d399 100%)" ;;
-    medium)
-      gauge_color_start="#f59e0b"; gauge_color_end="#fbbf24"
-      gauge_text_gradient="linear-gradient(135deg, #f59e0b 0%, #fbbf24 100%)" ;;
-    low)
-      gauge_color_start="#ef4444"; gauge_color_end="#f87171"
-      gauge_text_gradient="linear-gradient(135deg, #ef4444 0%, #f87171 100%)" ;;
+  high)
+    gauge_color_start="#10b981"
+    gauge_color_end="#34d399"
+    gauge_text_gradient="linear-gradient(135deg, #10b981 0%, #34d399 100%)"
+    ;;
+  medium)
+    gauge_color_start="#f59e0b"
+    gauge_color_end="#fbbf24"
+    gauge_text_gradient="linear-gradient(135deg, #f59e0b 0%, #fbbf24 100%)"
+    ;;
+  low)
+    gauge_color_start="#ef4444"
+    gauge_color_end="#f87171"
+    gauge_text_gradient="linear-gradient(135deg, #ef4444 0%, #f87171 100%)"
+    ;;
   esac
 
   {
-    cat << 'EOF'
+    cat <<'EOF'
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -872,7 +906,7 @@ function bashunit::coverage::generate_index_html() {
     .gauge-text { position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); text-align: center; width: 100%; }
 EOF
     echo "    .gauge-percent { font-size: 3.5rem; font-weight: 800; background: ${gauge_text_gradient}; -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text; line-height: 1; margin: 0; display: block; }"
-    cat << 'EOF'
+    cat <<'EOF'
     .gauge-label { color: var(--text-secondary); font-size: 0.9rem; text-transform: uppercase; letter-spacing: 2px; margin: 0; display: block; }
     .gauge-info { flex: 1; }
     .gauge-title { font-size: 1.8rem; font-weight: 700; margin-bottom: 12px; }
@@ -962,7 +996,7 @@ EOF
         </div>
 EOF
     echo "        <div class=\"header-badge\">v${BASHUNIT_VERSION:-0.0.0}</div>"
-    cat << 'EOF'
+    cat <<'EOF'
       </div>
       <h1 class="header-title">Code Coverage Report</h1>
       <p class="header-subtitle">Comprehensive line-by-line coverage analysis for your bash scripts</p>
@@ -977,18 +1011,18 @@ EOF
 EOF
     echo "              <stop offset=\"0%\" style=\"stop-color:${gauge_color_start}\"/>"
     echo "              <stop offset=\"100%\" style=\"stop-color:${gauge_color_end}\"/>"
-    cat << 'EOF'
+    cat <<'EOF'
             </linearGradient>
           </defs>
           <circle class="gauge-bg" cx="80" cy="80" r="70"/>
 EOF
     echo "          <circle class=\"gauge-fill\" cx=\"80\" cy=\"80\" r=\"70\" stroke-dasharray=\"440\" stroke-dashoffset=\"${gauge_offset}\"/>"
-    cat << 'EOF'
+    cat <<'EOF'
         </svg>
         <div class="gauge-text">
 EOF
     echo "          <div class=\"gauge-percent\">${total_pct}%</div>"
-    cat << 'EOF'
+    cat <<'EOF'
           <div class="gauge-label">Coverage</div>
         </div>
       </div>
@@ -996,7 +1030,7 @@ EOF
         <h2 class="gauge-title">Overall Code Coverage</h2>
 EOF
     echo "        <p class=\"gauge-description\"><strong>${total_hit} of ${total_executable}</strong> executable lines covered across <strong>${file_count} files</strong>.</p>"
-    cat << 'EOF'
+    cat <<'EOF'
 
         <div class="compact-metrics">
           <div class="metrics-group coverage-group">
@@ -1007,21 +1041,21 @@ EOF
                 <span class="breakdown-label">Total:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${total_executable} lines</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
               <div class="breakdown-item">
                 <span class="breakdown-dot covered"></span>
                 <span class="breakdown-label">Covered:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${total_hit} lines</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
               <div class="breakdown-item">
                 <span class="breakdown-dot uncovered"></span>
                 <span class="breakdown-label">Uncovered:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${total_uncovered} lines</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
             </div>
           </div>
@@ -1033,28 +1067,28 @@ EOF
                 <span class="breakdown-label">Files:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${file_count}</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
               <div class="breakdown-item">
                 <span class="breakdown-dot tests"></span>
                 <span class="breakdown-label">Tests:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${tests_total} total</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
               <div class="breakdown-item">
                 <span class="breakdown-dot tests-passed"></span>
                 <span class="breakdown-label">Passed:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${tests_passed}</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
               <div class="breakdown-item">
                 <span class="breakdown-dot tests-failed"></span>
                 <span class="breakdown-label">Failed:</span>
 EOF
     echo "                <span class=\"breakdown-value\">${tests_failed}</span>"
-    cat << 'EOF'
+    cat <<'EOF'
               </div>
             </div>
           </div>
@@ -1069,19 +1103,19 @@ EOF
             <span class="legend-color high"></span>
 EOF
     echo "            <span>≥${BASHUNIT_COVERAGE_THRESHOLD_HIGH:-80}% High</span>"
-    cat << 'EOF'
+    cat <<'EOF'
           </div>
           <div class="legend-item">
             <span class="legend-color medium"></span>
 EOF
     echo "            <span>${BASHUNIT_COVERAGE_THRESHOLD_LOW:-50}-${BASHUNIT_COVERAGE_THRESHOLD_HIGH:-80}% Medium</span>"
-    cat << 'EOF'
+    cat <<'EOF'
           </div>
           <div class="legend-item">
             <span class="legend-color low"></span>
 EOF
     echo "            <span>&lt;${BASHUNIT_COVERAGE_THRESHOLD_LOW:-50}% Low</span>"
-    cat << 'EOF'
+    cat <<'EOF'
           </div>
         </div>
       </div>
@@ -1097,8 +1131,9 @@ EOF
           <tbody>
 EOF
 
+    local data display_file hit executable pct safe_filename
     for data in ${file_data[@]+"${file_data[@]}"}; do
-      IFS='|' read -r display_file hit executable pct safe_filename <<< "$data"
+      IFS='|' read -r display_file hit executable pct safe_filename <<<"$data"
 
       local class
       class=$(bashunit::coverage::get_coverage_class "$pct")
@@ -1127,7 +1162,7 @@ EOF
       echo "            </tr>"
     done
 
-    cat << 'EOF'
+    cat <<'EOF'
           </tbody>
         </table>
       </div>
@@ -1145,7 +1180,7 @@ EOF
 </body>
 </html>
 EOF
-  } > "$output_file"
+  } >"$output_file"
 }
 
 function bashunit::coverage::generate_file_html() {
@@ -1169,7 +1204,7 @@ function bashunit::coverage::generate_file_html() {
 
   # Pre-load test hits data into indexed array (for tooltips)
   # Index: line number, Value: newline-separated list of "test_file:test_function"
-  # Using indexed array for Bash 3.2 compatibility (no associative arrays)
+  # Using indexed array for Bash 3.0 compatibility (no associative arrays)
   local -a tests_by_line=()
   local _line_and_test
   while IFS= read -r _line_and_test; do
@@ -1189,11 +1224,11 @@ function bashunit::coverage::generate_file_html() {
 
   # Count total lines and functions
   local total_lines
-  total_lines=$(wc -l < "$file" | tr -d ' ')
+  total_lines=$(wc -l <"$file" | tr -d ' ')
   local non_executable=$((total_lines - executable))
 
   {
-    cat << 'EOF'
+    cat <<'EOF'
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -1201,7 +1236,7 @@ function bashunit::coverage::generate_file_html() {
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 EOF
     echo "  <title>$(basename "$display_file") | Coverage Report</title>"
-    cat << 'EOF'
+    cat <<'EOF'
   <style>
     :root {
       --primary: #6366f1; --primary-dark: #4f46e5; --primary-light: #818cf8;
@@ -1340,20 +1375,20 @@ EOF
         <div class="file-title">
 EOF
     echo "          <span class=\"file-name\">$(basename "$display_file")</span>"
-    cat << 'EOF'
+    cat <<'EOF'
         </div>
       </div>
       <div class="stats-section">
         <div class="stat-item">
 EOF
     echo "          <span class=\"stat-badge coverage $class\">${pct}%</span>"
-    cat << 'EOF'
+    cat <<'EOF'
           <span class="stat-label">Coverage</span>
         </div>
         <div class="stat-item">
 EOF
     echo "          <span class=\"stat-badge lines\">${hit}/${executable}</span>"
-    cat << 'EOF'
+    cat <<'EOF'
           <span class="stat-label">Lines</span>
         </div>
       </div>
@@ -1366,12 +1401,12 @@ EOF
           <span class="progress-label">Line Coverage Progress</span>
 EOF
     echo "          <span class=\"progress-percent $class\">${pct}%</span>"
-    cat << 'EOF'
+    cat <<'EOF'
         </div>
         <div class="progress-bar">
 EOF
     echo "          <div class=\"progress-fill $class\" style=\"width: ${pct}%;\"></div>"
-    cat << 'EOF'
+    cat <<'EOF'
         </div>
       </div>
       <div class="legend">
@@ -1379,19 +1414,19 @@ EOF
           <span class="legend-color covered"></span>
 EOF
     echo "          <span>${hit} lines covered</span>"
-    cat << 'EOF'
+    cat <<'EOF'
         </div>
         <div class="legend-item">
           <span class="legend-color uncovered"></span>
 EOF
     echo "          <span>${uncovered} lines uncovered</span>"
-    cat << 'EOF'
+    cat <<'EOF'
         </div>
         <div class="legend-item">
           <span class="legend-color neutral"></span>
 EOF
     echo "          <span>${non_executable} non-executable</span>"
-    cat << 'EOF'
+    cat <<'EOF'
         </div>
       </div>
     </div>
@@ -1403,7 +1438,7 @@ EOF
     functions_data=$(bashunit::coverage::extract_functions "$file")
 
     if [[ -n "$functions_data" ]]; then
-      cat << 'EOF'
+      cat <<'EOF'
   <div class="function-summary">
     <table class="function-table">
       <thead>
@@ -1444,9 +1479,9 @@ EOF
         fn_pct=$(bashunit::coverage::calculate_percentage "$fn_hit" "$fn_executable")
         fn_class=$(bashunit::coverage::get_coverage_class "$fn_pct")
         case "$fn_class" in
-          high)   row_class="fn-covered" ;;
-          medium) row_class="fn-partial" ;;
-          low)    row_class="fn-uncovered" ;;
+        high) row_class="fn-covered" ;;
+        medium) row_class="fn-partial" ;;
+        low) row_class="fn-uncovered" ;;
         esac
 
         echo "        <tr class=\"$row_class\">"
@@ -1459,16 +1494,16 @@ EOF
         echo "            </div>"
         echo "          </td>"
         echo "        </tr>"
-      done <<< "$functions_data"
+      done <<<"$functions_data"
 
-      cat << 'EOF'
+      cat <<'EOF'
       </tbody>
     </table>
   </div>
 EOF
     fi
 
-    cat << 'EOF'
+    cat <<'EOF'
   <div class="code-container">
     <div class="code-wrapper">
       <div class="code-header">
@@ -1477,13 +1512,14 @@ EOF
     echo "        <div class=\"code-stats\">"
     echo "          <span>${total_lines} total lines</span>"
     echo "        </div>"
-    cat << 'EOF'
+    cat <<'EOF'
       </div>
       <div class="code-body">
         <table class="code-table">
 EOF
 
     local lineno=0
+    local line
     while IFS= read -r line || [[ -n "$line" ]]; do
       ((lineno++))
 
@@ -1505,13 +1541,14 @@ EOF
           if [[ -n "$test_info" ]]; then
             # Build tooltip with test information
             local tooltip_html="<div class=\"hits-tooltip\"><div class=\"hits-tooltip-title\">Tests hitting this line</div><ul class=\"hits-tooltip-list\">"
+            local test_file test_fn
             while IFS=':' read -r test_file test_fn; do
               [[ -z "$test_file" ]] && continue
               local short_file
               short_file=$(basename "$test_file")
-              tooltip_html+="<li><span class=\"hits-tooltip-file\">${short_file}</span>:<span class=\"hits-tooltip-fn\">${test_fn}</span></li>"
-            done <<< "$test_info"
-            tooltip_html+="</ul></div>"
+              tooltip_html="$tooltip_html<li><span class=\"hits-tooltip-file\">${short_file}</span>:<span class=\"hits-tooltip-fn\">${test_fn}</span></li>"
+            done <<<"$test_info"
+            tooltip_html="$tooltip_html</ul></div>"
             hits_display="<span class=\"hits-badge has-tooltip\">${hits}×${tooltip_html}</span>"
           else
             hits_display="<span class=\"hits-badge\">${hits}×</span>"
@@ -1527,9 +1564,9 @@ EOF
       echo "            <td class=\"hits\">$hits_display</td>"
       echo "            <td class=\"code\">$escaped_line</td>"
       echo "          </tr>"
-    done < "$file"
+    done <"$file"
 
-    cat << 'EOF'
+    cat <<'EOF'
         </table>
       </div>
     </div>
@@ -1542,7 +1579,7 @@ EOF
 </body>
 </html>
 EOF
-  } > "$output_file"
+  } >"$output_file"
 }
 
 function bashunit::coverage::cleanup() {
diff --git a/src/dependencies.sh b/src/dependencies.sh
index db3b9c62..c605167f 100644
--- a/src/dependencies.sh
+++ b/src/dependencies.sh
@@ -6,7 +6,7 @@ function bashunit::dependencies::has_perl() {
 }
 
 function bashunit::dependencies::has_powershell() {
-  command -v powershell > /dev/null 2>&1
+  command -v powershell >/dev/null 2>&1
 }
 
 function bashunit::dependencies::has_adjtimex() {
diff --git a/src/doc.sh b/src/doc.sh
index 803bb9a6..ab114a4d 100644
--- a/src/doc.sh
+++ b/src/doc.sh
@@ -11,13 +11,14 @@ function bashunit::doc::get_embedded_docs() {
 
 function bashunit::doc::print_asserts() {
   local filter="${1:-}"
-  local line
   local docstring=""
   local fn=""
   local should_print=0
 
+  local line
   while IFS='' read -r line || [[ -n "$line" ]]; do
-    if [[ $line =~ ^##\ ([A-Za-z0-9_]+) ]]; then
+    local _re='^## ([A-Za-z0-9_]+)'
+    if [[ "$line" =~ $_re ]]; then
       fn="${BASH_REMATCH[1]}"
       if [[ -z "$filter" || "$fn" == *"$filter"* ]]; then
         should_print=1
@@ -29,8 +30,10 @@ function bashunit::doc::print_asserts() {
       continue
     fi
 
-    if (( should_print )); then
-      if [[ "$line" =~ ^\`\`\` ]]; then
+    if ((should_print)); then
+      # Check for code fence using pattern matching instead of regex
+      # Avoids backtick escaping issues in Bash 3.0
+      if [[ "$line" == '```'* ]]; then
         echo "--------------"
         echo "$docstring"
         should_print=0
@@ -41,8 +44,8 @@ function bashunit::doc::print_asserts() {
 
       # Remove markdown link brackets and anchor tags
       line="${line//[\[\]]/}"
-      line="$(sed -E 's/ *\(#[-a-z0-9]+\)//g' <<< "$line")"
-      docstring+="$line"$'\n'
+      line="$(sed -E 's/ *\(#[-a-z0-9]+\)//g' <<<"$line")"
+      docstring="$docstring$line"$'\n'
     fi
-  done <<< "$(bashunit::doc::get_embedded_docs)"
+  done <<<"$(bashunit::doc::get_embedded_docs)"
 }
diff --git a/src/env.sh b/src/env.sh
index aed4a663..4b9f9f61 100644
--- a/src/env.sh
+++ b/src/env.sh
@@ -190,7 +190,7 @@ function bashunit::env::active_internet_connection() {
     wget -q --spider https://github.com && return 0
   fi
 
-  if ping -c 1 -W 3 google.com &> /dev/null; then
+  if ping -c 1 -W 3 google.com &>/dev/null; then
     return 0
   fi
 
@@ -200,11 +200,11 @@ function bashunit::env::active_internet_connection() {
 function bashunit::env::find_terminal_width() {
   local cols=""
 
-  if [[ -z "$cols" ]] && command -v tput > /dev/null; then
+  if [[ -z "$cols" ]] && command -v tput >/dev/null; then
     cols=$(tput cols 2>/dev/null)
   fi
 
-  if [[ -z "$cols" ]] && command -v stty > /dev/null; then
+  if [[ -z "$cols" ]] && command -v stty >/dev/null; then
     cols=$(stty size 2>/dev/null | cut -d' ' -f2)
   fi
 
@@ -214,7 +214,10 @@ function bashunit::env::find_terminal_width() {
 
 function bashunit::env::print_verbose() {
   bashunit::internal_log "Printing verbose environment variables"
-  local keys=(
+  local IFS=$' \t\n'
+  # Bash 3.0 compatible: separate declaration and assignment for arrays
+  local keys
+  keys=(
     "BASHUNIT_DEFAULT_PATH"
     "BASHUNIT_DEV_LOG"
     "BASHUNIT_BOOTSTRAP"
@@ -242,13 +245,14 @@ function bashunit::env::print_verbose() {
 
   local max_length=0
 
-  for key in "${keys[@]}"; do
-    if (( ${#key} > max_length )); then
+  local key
+  for key in "${keys[@]+"${keys[@]}"}"; do
+    if ((${#key} > max_length)); then
       max_length=${#key}
     fi
   done
 
-  for key in "${keys[@]}"; do
+  for key in "${keys[@]+"${keys[@]}"}"; do
     bashunit::internal_log "$key=${!key}"
     printf "%s:%*s%s\n" "$key" $((max_length - ${#key} + 1)) "" "${!key}"
   done
diff --git a/src/globals.sh b/src/globals.sh
index 336ce636..47161c9c 100644
--- a/src/globals.sh
+++ b/src/globals.sh
@@ -31,8 +31,9 @@ function bashunit::random_str() {
   local length=${1:-6}
   local chars='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
   local str=''
-  for (( i=0; i<length; i++ )); do
-    str+="${chars:RANDOM%${#chars}:1}"
+  local i
+  for ((i = 0; i < length; i++)); do
+    str="$str${chars:RANDOM%${#chars}:1}"
   done
   echo "$str"
 }
@@ -87,15 +88,18 @@ function bashunit::log() {
   shift
 
   case "$level" in
-    info|INFO)          level="INFO" ;;
-    debug|DEBUG)        level="DEBUG" ;;
-    warning|WARNING)    level="WARNING" ;;
-    critical|CRITICAL)  level="CRITICAL" ;;
-    error|ERROR)        level="ERROR" ;;
-    *) set -- "$level $@"; level="INFO" ;;
+  info | INFO) level="INFO" ;;
+  debug | DEBUG) level="DEBUG" ;;
+  warning | WARNING) level="WARNING" ;;
+  critical | CRITICAL) level="CRITICAL" ;;
+  error | ERROR) level="ERROR" ;;
+  *)
+    set -- "$level $@"
+    level="INFO"
+    ;;
   esac
 
-  echo "$(bashunit::current_timestamp) [$level]: $* #${BASH_SOURCE[1]}:${BASH_LINENO[0]}" >> "$BASHUNIT_DEV_LOG"
+  echo "$(bashunit::current_timestamp) [$level]: $* #${BASH_SOURCE[1]}:${BASH_LINENO[0]}" >>"$BASHUNIT_DEV_LOG"
 }
 
 function bashunit::internal_log() {
@@ -103,12 +107,12 @@ function bashunit::internal_log() {
     return
   fi
 
-  echo "$(bashunit::current_timestamp) [INTERNAL]: $* #${BASH_SOURCE[1]}:${BASH_LINENO[0]}" >> "$BASHUNIT_DEV_LOG"
+  echo "$(bashunit::current_timestamp) [INTERNAL]: $* #${BASH_SOURCE[1]}:${BASH_LINENO[0]}" >>"$BASHUNIT_DEV_LOG"
 }
 
 function bashunit::print_line() {
-  local length="${1:-70}"   # Default to 70 if not passed
-  local char="${2:--}"      # Default to '-' if not passed
+  local length="${1:-70}" # Default to 70 if not passed
+  local char="${2:--}"    # Default to '-' if not passed
   printf '%*s\n' "$length" '' | tr ' ' "$char"
 }
 
@@ -118,11 +122,21 @@ function bashunit::data_set() {
 
   for arg in "$@"; do
     if [ "$first" = true ]; then
-      printf '%q' "$arg"
+      # Bash 3.0 compatible: printf '%q' "" produces nothing in Bash 3.0
+      if [[ -z "$arg" ]]; then
+        printf "''"
+      else
+        printf '%q' "$arg"
+      fi
       first=false
     else
-      printf ' %q' "$arg"
+      if [[ -z "$arg" ]]; then
+        printf " ''"
+      else
+        printf ' %q' "$arg"
+      fi
     fi
   done
-  printf ' %q\n' ""
+  # Sentinel empty string at end
+  printf " ''\n"
 }
diff --git a/src/helpers.sh b/src/helpers.sh
index adc13d8b..a4cc18bb 100755
--- a/src/helpers.sh
+++ b/src/helpers.sh
@@ -17,7 +17,8 @@ function bashunit::helper::find_test_function_name() {
   for ((i = 0; i < ${#FUNCNAME[@]}; i++)); do
     local fn="${FUNCNAME[$i]}"
     # Check if function starts with "test_" or "test" followed by uppercase
-    if [[ "$fn" == test_* ]] || [[ "$fn" =~ ^test[A-Z] ]]; then
+    local _re='^test[A-Z]'
+    if [[ "$fn" == test_* ]] || [[ "$fn" =~ $_re ]]; then
       echo "$fn"
       return
     fi
@@ -68,16 +69,16 @@ function bashunit::helper::normalize_test_function_name() {
   fi
   # Replace underscores with spaces
   result="${result//_/ }"
-  # Capitalize the first letter (bash 3.2 compatible, no subprocess)
+  # Capitalize the first letter (bash 3.0 compatible, no subprocess)
   local first_char="${result:0:1}"
   case "$first_char" in
-    a) first_char='A' ;; b) first_char='B' ;; c) first_char='C' ;; d) first_char='D' ;;
-    e) first_char='E' ;; f) first_char='F' ;; g) first_char='G' ;; h) first_char='H' ;;
-    i) first_char='I' ;; j) first_char='J' ;; k) first_char='K' ;; l) first_char='L' ;;
-    m) first_char='M' ;; n) first_char='N' ;; o) first_char='O' ;; p) first_char='P' ;;
-    q) first_char='Q' ;; r) first_char='R' ;; s) first_char='S' ;; t) first_char='T' ;;
-    u) first_char='U' ;; v) first_char='V' ;; w) first_char='W' ;; x) first_char='X' ;;
-    y) first_char='Y' ;; z) first_char='Z' ;;
+  a) first_char='A' ;; b) first_char='B' ;; c) first_char='C' ;; d) first_char='D' ;;
+  e) first_char='E' ;; f) first_char='F' ;; g) first_char='G' ;; h) first_char='H' ;;
+  i) first_char='I' ;; j) first_char='J' ;; k) first_char='K' ;; l) first_char='L' ;;
+  m) first_char='M' ;; n) first_char='N' ;; o) first_char='O' ;; p) first_char='P' ;;
+  q) first_char='Q' ;; r) first_char='R' ;; s) first_char='S' ;; t) first_char='T' ;;
+  u) first_char='U' ;; v) first_char='V' ;; w) first_char='W' ;; x) first_char='X' ;;
+  y) first_char='Y' ;; z) first_char='Z' ;;
   esac
   result="${first_char}${result:1}"
 
@@ -93,11 +94,14 @@ function bashunit::helper::escape_single_quotes() {
 function bashunit::helper::interpolate_function_name() {
   local function_name="$1"
   shift
-  local args=("$@")
+  local -a args
+  local args_count=$#
+  args=("$@")
   local result="$function_name"
 
-  for ((i=0; i<${#args[@]}; i++)); do
-    local placeholder="::$((i+1))::"
+  local i
+  for ((i = 0; i < args_count; i++)); do
+    local placeholder="::$((i + 1))::"
     # shellcheck disable=SC2155
     local value="$(bashunit::helper::escape_single_quotes "${args[$i]}")"
     value="'$value'"
@@ -110,6 +114,12 @@ function bashunit::helper::interpolate_function_name() {
 function bashunit::helper::encode_base64() {
   local value="$1"
 
+  # Handle empty string specially - base64 of "" is "", which gets lost in line parsing
+  if [[ -z "$value" ]]; then
+    printf '%s' "_BASHUNIT_EMPTY_"
+    return
+  fi
+
   if command -v base64 >/dev/null; then
     printf '%s' "$value" | base64 -w 0 2>/dev/null || printf '%s' "$value" | base64 | tr -d '\n'
   else
@@ -120,6 +130,12 @@ function bashunit::helper::encode_base64() {
 function bashunit::helper::decode_base64() {
   local value="$1"
 
+  # Handle empty string marker
+  if [[ "$value" == "_BASHUNIT_EMPTY_" ]]; then
+    printf ''
+    return
+  fi
+
   if command -v base64 >/dev/null; then
     printf '%s' "$value" | base64 -d
   else
@@ -172,12 +188,13 @@ function bashunit::helper::get_functions_to_run() {
 
   local filtered_functions=""
 
+  local fn
   for fn in $function_names; do
     if [[ $fn == ${prefix}_*${filter}* ]]; then
       if [[ $filtered_functions == *" $fn"* ]]; then
         return 1
       fi
-      filtered_functions+=" $fn"
+      filtered_functions="$filtered_functions $fn"
     fi
   done
 
@@ -211,7 +228,8 @@ function bashunit::helper::find_files_recursive() {
   local pattern="${2:-*[tT]est.sh}"
 
   local alt_pattern=""
-  if [[ $pattern == *test.sh ]] || [[ $pattern =~ \[tT\]est\.sh$ ]]; then
+  local _re='\[tT\]est\.sh$'
+  if [[ $pattern == *test.sh ]] || [[ "$pattern" =~ $_re ]]; then
     alt_pattern="${pattern%.sh}.bash"
   fi
 
@@ -238,7 +256,8 @@ function bashunit::helper::normalize_variable_name() {
 
   normalized_string="${input_string//[^a-zA-Z0-9_]/_}"
 
-  if [[ ! $normalized_string =~ ^[a-zA-Z_] ]]; then
+  local _re='^[a-zA-Z_]'
+  if ! [[ "$normalized_string" =~ $_re ]]; then
     normalized_string="_$normalized_string"
   fi
 
@@ -262,8 +281,8 @@ function bashunit::helper::get_provider_data() {
   local data_provider_function
   data_provider_function=$(
     # shellcheck disable=SC1087
-    grep -B 2 -E "(function[[:space:]]+)?$function_name[[:space:]]*\(\)" "$script" 2>/dev/null | \
-    sed -nE 's/^[[:space:]]*# *@?data_provider[[:space:]]+//p'
+    grep -B 2 -E "(function[[:space:]]+)?$function_name[[:space:]]*\(\)" "$script" 2>/dev/null |
+      sed -nE 's/^[[:space:]]*# *@?data_provider[[:space:]]+//p'
   )
 
   if [[ -n "$data_provider_function" ]]; then
@@ -295,95 +314,96 @@ function bashunit::helper::get_latest_tag() {
 }
 
 function bashunit::helper::find_total_tests() {
-    local filter=${1:-}
-    local files=("${@:2}")
+  local filter=${1:-}
+  shift || true
+
+  if [[ $# -eq 0 ]]; then
+    echo 0
+    return
+  fi
+
+  local total_count=0
+  local file
 
-    if [[ ${#files[@]} -eq 0 ]]; then
-        echo 0
-        return
+  for file in "$@"; do
+    if [[ ! -f "$file" ]]; then
+      continue
     fi
 
-    local total_count=0
-    local file
-
-    for file in "${files[@]}"; do
-        if [[ ! -f "$file" ]]; then
-            continue
-        fi
-
-        local file_count
-        file_count=$( (
-            # shellcheck source=/dev/null
-            source "$file"
-            local all_fn_names
-            all_fn_names=$(declare -F | awk '{print $3}')
-            local filtered_functions
-            filtered_functions=$(bashunit::helper::get_functions_to_run "test" "$filter" "$all_fn_names") || true
-
-            local count=0
-            if [[ -n "$filtered_functions" ]]; then
-                # shellcheck disable=SC2206
-                # shellcheck disable=SC2207
-                local functions_to_run=($filtered_functions)
-                for fn_name in "${functions_to_run[@]}"; do
-                    local provider_data=()
-                    while IFS=" " read -r line; do
-                        provider_data+=("$line")
-                    done <<< "$(bashunit::helper::get_provider_data "$fn_name" "$file")"
-
-                    if [[ "${#provider_data[@]}" -eq 0 ]]; then
-                        count=$((count + 1))
-                    else
-                        count=$((count + ${#provider_data[@]}))
-                    fi
-                done
-            fi
-
-            echo "$count"
-        ) )
-
-        total_count=$((total_count + file_count))
-    done
-
-    echo "$total_count"
-}
+    local file_count
+    file_count=$( (
+      # shellcheck source=/dev/null
+      source "$file"
+      local all_fn_names
+      all_fn_names=$(declare -F | awk '{print $3}')
+      local filtered_functions
+      filtered_functions=$(bashunit::helper::get_functions_to_run "test" "$filter" "$all_fn_names") || true
+
+      local count=0
+      local IFS=$' \t\n'
+      if [[ -n "$filtered_functions" ]]; then
+        local -a functions_to_run=()
+        # shellcheck disable=SC2206
+        functions_to_run=($filtered_functions)
+        # shellcheck disable=SC2034
+        local -a provider_data=()
+        local provider_data_count=0
+        local fn_name line
+        for fn_name in "${functions_to_run[@]+"${functions_to_run[@]}"}"; do
+          provider_data=()
+          provider_data_count=0
+          while IFS=" " read -r line; do
+            [[ -z "$line" ]] && continue
+            # shellcheck disable=SC2034
+            provider_data[provider_data_count]="$line"
+            provider_data_count=$((provider_data_count + 1))
+          done <<<"$(bashunit::helper::get_provider_data "$fn_name" "$file")"
+
+          if [[ "$provider_data_count" -eq 0 ]]; then
+            count=$((count + 1))
+          else
+            count=$((count + provider_data_count))
+          fi
+        done
+      fi
 
-function bashunit::helper::load_test_files() {
-  local filter=$1
-  local files=("${@:2}")
+      echo "$count"
+    ))
+
+    total_count=$((total_count + file_count))
+  done
 
-  local test_files=()
+  echo "$total_count"
+}
 
-  if [[ "${#files[@]}" -eq 0 ]]; then
-    if [[ -n "${BASHUNIT_DEFAULT_PATH}" ]]; then
-      while IFS='' read -r line; do
-        test_files+=("$line")
-      done < <(bashunit::helper::find_files_recursive "$BASHUNIT_DEFAULT_PATH")
+function bashunit::helper::load_test_files() {
+  local filter="${1:-}"
+  shift || true
+  # Bash 3.0 compatible: use $# after shift to check for files
+  local has_files=$#
+
+  if [[ "$has_files" -eq 0 ]]; then
+    if [[ -n "${BASHUNIT_DEFAULT_PATH:-}" ]]; then
+      bashunit::helper::find_files_recursive "$BASHUNIT_DEFAULT_PATH"
     fi
   else
-    test_files=("${files[@]}")
+    printf "%s\n" "$@"
   fi
-
-  printf "%s\n" "${test_files[@]}"
 }
 
 function bashunit::helper::load_bench_files() {
-  local filter=$1
-  local files=("${@:2}")
-
-  local bench_files=()
-
-  if [[ "${#files[@]}" -eq 0 ]]; then
-    if [[ -n "${BASHUNIT_DEFAULT_PATH}" ]]; then
-      while IFS='' read -r line; do
-        bench_files+=("$line")
-      done < <(bashunit::helper::find_files_recursive "$BASHUNIT_DEFAULT_PATH" '*[bB]ench.sh')
+  local filter="${1:-}"
+  shift || true
+  # Bash 3.0 compatible: use $# after shift to check for files
+  local has_files=$#
+
+  if [[ "$has_files" -eq 0 ]]; then
+    if [[ -n "${BASHUNIT_DEFAULT_PATH:-}" ]]; then
+      bashunit::helper::find_files_recursive "$BASHUNIT_DEFAULT_PATH" '*[bB]ench.sh'
     fi
   else
-    bench_files=("${files[@]}")
+    printf "%s\n" "$@"
   fi
-
-  printf "%s\n" "${bench_files[@]}"
 }
 
 #
@@ -432,13 +452,16 @@ function bashunit::helper::parse_file_path_filter() {
     file_path="${input%%::*}"
     filter="${input#*::}"
   # Check for :number syntax (line number filter)
-  elif [[ "$input" =~ ^(.+):([0-9]+)$ ]]; then
-    file_path="${BASH_REMATCH[1]}"
-    local line_number="${BASH_REMATCH[2]}"
-    # Line number will be resolved to function name later
-    filter="__line__:${line_number}"
   else
-    file_path="$input"
+    local _re='^(.+):([0-9]+)$'
+    if [[ "$input" =~ $_re ]]; then
+      file_path="${BASH_REMATCH[1]}"
+      local line_number="${BASH_REMATCH[2]}"
+      # Line number will be resolved to function name later
+      filter="__line__:${line_number}"
+    else
+      file_path="$input"
+    fi
   fi
 
   echo "$file_path"
@@ -465,10 +488,12 @@ function bashunit::helper::find_function_at_line() {
   local best_match=""
   local best_line=0
 
+  local line_num content
   while IFS=: read -r line_num content; do
     # Extract function name from the line
     local fn_name=""
-    if [[ "$content" =~ ^[[:space:]]*(function[[:space:]]+)?(test[a-zA-Z_][a-zA-Z0-9_]*)[[:space:]]*\(\) ]]; then
+    local fn_pattern='^[[:space:]]*(function[[:space:]]+)?(test[a-zA-Z_][a-zA-Z0-9_]*)[[:space:]]*\(\)'
+    if [[ "$content" =~ $fn_pattern ]]; then
       fn_name="${BASH_REMATCH[2]}"
     fi
 
diff --git a/src/init.sh b/src/init.sh
index 15dad6b7..c7259a52 100644
--- a/src/init.sh
+++ b/src/init.sh
@@ -38,9 +38,9 @@ SH
         sed -i -e "s/^BASHUNIT_BOOTSTRAP=/#&/" "$env_file"
       fi
     fi
-    echo "$env_line" >> "$env_file"
+    echo "$env_line" >>"$env_file"
   else
-    echo "$env_line" > "$env_file"
+    echo "$env_line" >"$env_file"
   fi
 
   echo "> bashunit initialized in $tests_dir"
diff --git a/src/learn.sh b/src/learn.sh
index d714e278..0972cd09 100644
--- a/src/learn.sh
+++ b/src/learn.sh
@@ -67,25 +67,25 @@ function bashunit::learn::start() {
     echo ""
 
     case "$choice" in
-      1) bashunit::learn::lesson_basics || true ;;
-      2) bashunit::learn::lesson_assertions || true ;;
-      3) bashunit::learn::lesson_lifecycle || true ;;
-      4) bashunit::learn::lesson_functions || true ;;
-      5) bashunit::learn::lesson_scripts || true ;;
-      6) bashunit::learn::lesson_mocking || true ;;
-      7) bashunit::learn::lesson_spies || true ;;
-      8) bashunit::learn::lesson_data_providers || true ;;
-      9) bashunit::learn::lesson_exit_codes || true ;;
-      10) bashunit::learn::lesson_challenge || true ;;
-      p) bashunit::learn::show_progress ;;
-      r) bashunit::learn::reset_progress ;;
-      q)
-        echo "${_BASHUNIT_COLOR_PASSED}Happy testing!${_BASHUNIT_COLOR_DEFAULT}"
-        break
-        ;;
-      *)
-        echo "${_BASHUNIT_COLOR_FAILED}Invalid choice. Please try again.${_BASHUNIT_COLOR_DEFAULT}"
-        ;;
+    1) bashunit::learn::lesson_basics || true ;;
+    2) bashunit::learn::lesson_assertions || true ;;
+    3) bashunit::learn::lesson_lifecycle || true ;;
+    4) bashunit::learn::lesson_functions || true ;;
+    5) bashunit::learn::lesson_scripts || true ;;
+    6) bashunit::learn::lesson_mocking || true ;;
+    7) bashunit::learn::lesson_spies || true ;;
+    8) bashunit::learn::lesson_data_providers || true ;;
+    9) bashunit::learn::lesson_exit_codes || true ;;
+    10) bashunit::learn::lesson_challenge || true ;;
+    p) bashunit::learn::show_progress ;;
+    r) bashunit::learn::reset_progress ;;
+    q)
+      echo "${_BASHUNIT_COLOR_PASSED}Happy testing!${_BASHUNIT_COLOR_DEFAULT}"
+      break
+      ;;
+    *)
+      echo "${_BASHUNIT_COLOR_FAILED}Invalid choice. Please try again.${_BASHUNIT_COLOR_DEFAULT}"
+      ;;
     esac
   done
 
@@ -97,7 +97,7 @@ function bashunit::learn::start() {
 ##
 function bashunit::learn::mark_completed() {
   local lesson=$1
-  echo "$lesson" >> "$LEARN_PROGRESS_FILE"
+  echo "$lesson" >>"$LEARN_PROGRESS_FILE"
 }
 
 ##
@@ -123,6 +123,7 @@ function bashunit::learn::show_progress() {
   local total_lessons=10
   local completed=0
 
+  local i
   for i in $(seq 1 $total_lessons); do
     if bashunit::learn::is_completed "lesson_$i"; then
       echo "  ${_BASHUNIT_COLOR_PASSED}✓${_BASHUNIT_COLOR_DEFAULT} Lesson $i completed"
@@ -163,7 +164,7 @@ function bashunit::learn::create_example_file() {
 
   echo ""
   echo "Creating example file ${_BASHUNIT_COLOR_BOLD}$filename${_BASHUNIT_COLOR_DEFAULT}..."
-  echo "$content" > "$filename"
+  echo "$content" >"$filename"
   chmod +x "$filename"
   echo "${_BASHUNIT_COLOR_PASSED}✓ Created $filename${_BASHUNIT_COLOR_DEFAULT}"
   echo ""
@@ -333,9 +334,9 @@ function test_multiple_assertions() {
     return 1
   fi
 
-  if ! grep -q "assert_contains" "$test_file" || \
-      ! grep -q "assert_matches" "$test_file" || \
-      ! grep -q "assert_not_empty" "$test_file"; then
+  if ! grep -q "assert_contains" "$test_file" ||
+    ! grep -q "assert_matches" "$test_file" ||
+    ! grep -q "assert_not_empty" "$test_file"; then
     echo "${_BASHUNIT_COLOR_FAILED}Your test should use all three assertion types${_BASHUNIT_COLOR_DEFAULT}"
     read -p "Press Enter to continue..." -r
     return 1
@@ -426,8 +427,8 @@ function test_file_has_content() {
     return 1
   fi
 
-  if ! grep -q "function set_up()" "$test_file" || \
-      ! grep -q "function tear_down()" "$test_file"; then
+  if ! grep -q "function set_up()" "$test_file" ||
+    ! grep -q "function tear_down()" "$test_file"; then
     echo "${_BASHUNIT_COLOR_FAILED}Your test should define set_up and tear_down functions${_BASHUNIT_COLOR_DEFAULT}"
     read -p "Press Enter to continue..." -r
     return 1
@@ -858,7 +859,8 @@ File: validator.sh
 #!/usr/bin/env bash
 
 function is_valid_email() {
-  [[ $1 =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]
+  local email_pattern='^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+  [[ $1 =~ $email_pattern ]]
 }
 ───────────────────────────────────────────────────────────────
 
@@ -1157,17 +1159,20 @@ function test_backup_failure_when_source_missing() {
   fi
 
   # Verify the test has key components
-  local missing_components=()
+  local -a missing_components=()
+  local missing_components_count=0
 
   if ! grep -q "function set_up()" "$test_file"; then
-    missing_components+=("set_up function")
+    missing_components[missing_components_count]="set_up function"
+    missing_components_count=$((missing_components_count + 1))
   fi
 
   if ! grep -q "function tear_down()" "$test_file"; then
-    missing_components+=("tear_down function")
+    missing_components[missing_components_count]="tear_down function"
+    missing_components_count=$((missing_components_count + 1))
   fi
 
-  if [[ ${#missing_components[@]} -gt 0 ]]; then
+  if [[ "$missing_components_count" -gt 0 ]]; then
     echo "${_BASHUNIT_COLOR_FAILED}Missing required components:${_BASHUNIT_COLOR_DEFAULT}"
     printf "  - %s\n" "${missing_components[@]}"
     read -p "Press Enter to continue..." -r
diff --git a/src/main.sh b/src/main.sh
index fd06a834..b75034b8 100644
--- a/src/main.sh
+++ b/src/main.sh
@@ -5,153 +5,161 @@
 #############################
 function bashunit::main::cmd_test() {
   local filter=""
-  local raw_args=()
-  local args=()
+  local IFS=$' \t\n'
+  local -a raw_args=()
+  local raw_args_count=0
+  local -a args=()
+  local args_count=0
   local assert_fn=""
   local _bashunit_coverage_opt_set=false
 
   # Parse test-specific options
   while [[ $# -gt 0 ]]; do
     case "$1" in
-      -a|--assert)
-        assert_fn="$2"
-        shift
-        ;;
-      -f|--filter)
-        filter="$2"
-        shift
-        ;;
-      -s|--simple)
-        export BASHUNIT_SIMPLE_OUTPUT=true
-        ;;
-      --detailed)
-        export BASHUNIT_SIMPLE_OUTPUT=false
-        ;;
-      --debug)
-        local output_file="${2:-}"
-        if [[ -n "$output_file" && "${output_file:0:1}" != "-" ]]; then
-          exec > "$output_file" 2>&1
-          shift
-        fi
-        set -x
-        ;;
-      -S|--stop-on-failure)
-        export BASHUNIT_STOP_ON_FAILURE=true
-        ;;
-      -p|--parallel)
-        export BASHUNIT_PARALLEL_RUN=true
-        ;;
-      --no-parallel)
-        export BASHUNIT_PARALLEL_RUN=false
-        ;;
-      -e|--env|--boot)
-        # Support: --env "bootstrap.sh arg1 arg2"
-        local boot_file="${2%% *}"
-        local boot_args="${2#* }"
-        if [[ "$boot_args" != "$2" ]]; then
-          export BASHUNIT_BOOTSTRAP_ARGS="$boot_args"
-        fi
-        # shellcheck disable=SC1090,SC2086
-        source "$boot_file" ${BASHUNIT_BOOTSTRAP_ARGS:-}
-        shift
-        ;;
-      --log-junit)
-        export BASHUNIT_LOG_JUNIT="$2"
-        shift
-        ;;
-      -r|--report-html)
-        export BASHUNIT_REPORT_HTML="$2"
-        shift
-        ;;
-      --no-output)
-        export BASHUNIT_NO_OUTPUT=true
-        ;;
-      -vvv|--verbose)
-        export BASHUNIT_VERBOSE=true
-        ;;
-      -h|--help)
-        bashunit::console_header::print_test_help
-        exit 0
-        ;;
-      --show-skipped)
-        export BASHUNIT_SHOW_SKIPPED=true
-        ;;
-      --show-incomplete)
-        export BASHUNIT_SHOW_INCOMPLETE=true
-        ;;
-      --failures-only)
-        export BASHUNIT_FAILURES_ONLY=true
-        ;;
-      --show-output)
-        export BASHUNIT_SHOW_OUTPUT_ON_FAILURE=true
-        ;;
-      --no-output-on-failure)
-        export BASHUNIT_SHOW_OUTPUT_ON_FAILURE=false
-        ;;
-      --no-progress)
-        export BASHUNIT_NO_PROGRESS=true
-        ;;
-      --strict)
-        export BASHUNIT_STRICT_MODE=true
-        ;;
-      -R|--run-all)
-        export BASHUNIT_STOP_ON_ASSERTION_FAILURE=false
-        ;;
-      --skip-env-file)
-        export BASHUNIT_SKIP_ENV_FILE=true
-        ;;
-      -l|--login)
-        export BASHUNIT_LOGIN_SHELL=true
-        ;;
-      --no-color)
-        # shellcheck disable=SC2034
-        BASHUNIT_NO_COLOR=true
-        ;;
-      --coverage)
-        # Don't export - prevents nested bashunit runs from inheriting coverage
-        # shellcheck disable=SC2034
-        BASHUNIT_COVERAGE=true
-        ;;
-      --coverage-paths)
-        # shellcheck disable=SC2034
-        BASHUNIT_COVERAGE_PATHS="$2"
-        shift
-        ;;
-      --coverage-exclude)
-        # shellcheck disable=SC2034
-        BASHUNIT_COVERAGE_EXCLUDE="$2"
-        shift
-        ;;
-      --coverage-report)
-        # shellcheck disable=SC2034
-        BASHUNIT_COVERAGE_REPORT="$2"
-        _bashunit_coverage_opt_set=true
+    -a | --assert)
+      assert_fn="$2"
+      shift
+      ;;
+    -f | --filter)
+      filter="$2"
+      shift
+      ;;
+    -s | --simple)
+      export BASHUNIT_SIMPLE_OUTPUT=true
+      ;;
+    --detailed)
+      export BASHUNIT_SIMPLE_OUTPUT=false
+      ;;
+    --debug)
+      local output_file="${2:-}"
+      if [[ -n "$output_file" && "${output_file:0:1}" != "-" ]]; then
+        exec >"$output_file" 2>&1
         shift
-        ;;
-      --coverage-min)
-        # shellcheck disable=SC2034
-        BASHUNIT_COVERAGE_MIN="$2"
-        _bashunit_coverage_opt_set=true
+      fi
+      set -x
+      ;;
+    -S | --stop-on-failure)
+      export BASHUNIT_STOP_ON_FAILURE=true
+      ;;
+    -p | --parallel)
+      export BASHUNIT_PARALLEL_RUN=true
+      ;;
+    --no-parallel)
+      export BASHUNIT_PARALLEL_RUN=false
+      ;;
+    -e | --env | --boot)
+      # Support: --env "bootstrap.sh arg1 arg2"
+      local boot_file="${2%% *}"
+      local boot_args="${2#* }"
+      if [[ "$boot_args" != "$2" ]]; then
+        export BASHUNIT_BOOTSTRAP_ARGS="$boot_args"
+      fi
+      # Export all variables from the env file so they're available in subshells
+      # (e.g., process substitution used in load_test_files)
+      set -o allexport
+      # shellcheck disable=SC1090,SC2086
+      source "$boot_file" ${BASHUNIT_BOOTSTRAP_ARGS:-}
+      set +o allexport
+      shift
+      ;;
+    --log-junit)
+      export BASHUNIT_LOG_JUNIT="$2"
+      shift
+      ;;
+    -r | --report-html)
+      export BASHUNIT_REPORT_HTML="$2"
+      shift
+      ;;
+    --no-output)
+      export BASHUNIT_NO_OUTPUT=true
+      ;;
+    -vvv | --verbose)
+      export BASHUNIT_VERBOSE=true
+      ;;
+    -h | --help)
+      bashunit::console_header::print_test_help
+      exit 0
+      ;;
+    --show-skipped)
+      export BASHUNIT_SHOW_SKIPPED=true
+      ;;
+    --show-incomplete)
+      export BASHUNIT_SHOW_INCOMPLETE=true
+      ;;
+    --failures-only)
+      export BASHUNIT_FAILURES_ONLY=true
+      ;;
+    --show-output)
+      export BASHUNIT_SHOW_OUTPUT_ON_FAILURE=true
+      ;;
+    --no-output-on-failure)
+      export BASHUNIT_SHOW_OUTPUT_ON_FAILURE=false
+      ;;
+    --no-progress)
+      export BASHUNIT_NO_PROGRESS=true
+      ;;
+    --strict)
+      export BASHUNIT_STRICT_MODE=true
+      ;;
+    -R | --run-all)
+      export BASHUNIT_STOP_ON_ASSERTION_FAILURE=false
+      ;;
+    --skip-env-file)
+      export BASHUNIT_SKIP_ENV_FILE=true
+      ;;
+    -l | --login)
+      export BASHUNIT_LOGIN_SHELL=true
+      ;;
+    --no-color)
+      # shellcheck disable=SC2034
+      BASHUNIT_NO_COLOR=true
+      ;;
+    --coverage)
+      # Don't export - prevents nested bashunit runs from inheriting coverage
+      # shellcheck disable=SC2034
+      BASHUNIT_COVERAGE=true
+      ;;
+    --coverage-paths)
+      # shellcheck disable=SC2034
+      BASHUNIT_COVERAGE_PATHS="$2"
+      shift
+      ;;
+    --coverage-exclude)
+      # shellcheck disable=SC2034
+      BASHUNIT_COVERAGE_EXCLUDE="$2"
+      shift
+      ;;
+    --coverage-report)
+      # shellcheck disable=SC2034
+      BASHUNIT_COVERAGE_REPORT="$2"
+      _bashunit_coverage_opt_set=true
+      shift
+      ;;
+    --coverage-min)
+      # shellcheck disable=SC2034
+      BASHUNIT_COVERAGE_MIN="$2"
+      _bashunit_coverage_opt_set=true
+      shift
+      ;;
+    --no-coverage-report)
+      # shellcheck disable=SC2034
+      BASHUNIT_COVERAGE_REPORT=""
+      ;;
+    --coverage-report-html)
+      # shellcheck disable=SC2034
+      # Use default if no value provided or next arg is a flag
+      if [[ -z "${2:-}" || "${2:-}" == -* ]]; then
+        BASHUNIT_COVERAGE_REPORT_HTML="coverage/html"
+      else
+        BASHUNIT_COVERAGE_REPORT_HTML="$2"
         shift
-        ;;
-      --no-coverage-report)
-        # shellcheck disable=SC2034
-        BASHUNIT_COVERAGE_REPORT=""
-        ;;
-      --coverage-report-html)
-        # shellcheck disable=SC2034
-        # Use default if no value provided or next arg is a flag
-        if [[ -z "${2:-}" || "${2:-}" == -* ]]; then
-          BASHUNIT_COVERAGE_REPORT_HTML="coverage/html"
-        else
-          BASHUNIT_COVERAGE_REPORT_HTML="$2"
-          shift
-        fi
-        _bashunit_coverage_opt_set=true
-        ;;
-      *)
-        raw_args+=("$1")
-        ;;
+      fi
+      _bashunit_coverage_opt_set=true
+      ;;
+    *)
+      raw_args[raw_args_count]="$1"
+      raw_args_count=$((raw_args_count + 1))
+      ;;
     esac
     shift
   done
@@ -166,13 +174,15 @@ function bashunit::main::cmd_test() {
   # Skip filter parsing for assert mode - args are not file paths
   local inline_filter=""
   local inline_filter_file=""
-  if [[ ${#raw_args[@]} -gt 0 ]]; then
+  if [[ "$raw_args_count" -gt 0 ]]; then
     if [[ -n "$assert_fn" ]]; then
       # Assert mode: pass args as-is without file path processing
       args=("${raw_args[@]}")
+      args_count="$raw_args_count"
     else
       # Test mode: process file paths and extract inline filters
-      for arg in "${raw_args[@]}"; do
+      local arg
+      for arg in "${raw_args[@]+"${raw_args[@]}"}"; do
         local parsed_path parsed_filter
         {
           read -r parsed_path
@@ -185,8 +195,10 @@ function bashunit::main::cmd_test() {
           inline_filter_file="$parsed_path"
         fi
 
+        local file
         while IFS= read -r file; do
-          args+=("$file")
+          args[args_count]="$file"
+          args_count=$((args_count + 1))
         done < <(bashunit::helper::find_files_recursive "$parsed_path" '*[tT]est.sh')
       done
 
@@ -196,7 +208,7 @@ function bashunit::main::cmd_test() {
         local resolved_file="${inline_filter_file}"
 
         # If the file path was a pattern, use the first resolved file
-        if [[ ${#args[@]} -gt 0 ]]; then
+        if [[ "$args_count" -gt 0 ]]; then
           resolved_file="${args[0]}"
         fi
 
@@ -233,9 +245,15 @@ function bashunit::main::cmd_test() {
     # not tracking code coverage. This also prevents issues when parent bashunit
     # runs with coverage and calls subprocess bashunit with -a flag.
     export BASHUNIT_COVERAGE=false
-    bashunit::main::exec_assert "$assert_fn" "${args[@]}"
+    bashunit::main::exec_assert "$assert_fn" ${args+"${args[@]}"}
   else
-    bashunit::main::exec_tests "$filter" "${args[@]}"
+    # Bash 3.0 compatible: only pass args if we have files
+    # (local args without =() creates a scalar, not an empty array)
+    if [[ "$args_count" -gt 0 ]]; then
+      bashunit::main::exec_tests "$filter" "${args[@]}"
+    else
+      bashunit::main::exec_tests "$filter"
+    fi
   fi
 }
 
@@ -244,64 +262,74 @@ function bashunit::main::cmd_test() {
 #############################
 function bashunit::main::cmd_bench() {
   local filter=""
-  local raw_args=()
-  local args=()
+  local IFS=$' \t\n'
+  local -a raw_args=()
+  local raw_args_count=0
+  local -a args=()
+  local args_count=0
 
   export BASHUNIT_BENCH_MODE=true
 
   # Parse bench-specific options
   while [[ $# -gt 0 ]]; do
     case "$1" in
-      -f|--filter)
-        filter="$2"
-        shift
-        ;;
-      -s|--simple)
-        export BASHUNIT_SIMPLE_OUTPUT=true
-        ;;
-      --detailed)
-        export BASHUNIT_SIMPLE_OUTPUT=false
-        ;;
-      -e|--env|--boot)
-        # Support: --env "bootstrap.sh arg1 arg2"
-        local boot_file="${2%% *}"
-        local boot_args="${2#* }"
-        if [[ "$boot_args" != "$2" ]]; then
-          export BASHUNIT_BOOTSTRAP_ARGS="$boot_args"
-        fi
-        # shellcheck disable=SC1090,SC2086
-        source "$boot_file" ${BASHUNIT_BOOTSTRAP_ARGS:-}
-        shift
-        ;;
-      -vvv|--verbose)
-        export BASHUNIT_VERBOSE=true
-        ;;
-      --skip-env-file)
-        export BASHUNIT_SKIP_ENV_FILE=true
-        ;;
-      -l|--login)
-        export BASHUNIT_LOGIN_SHELL=true
-        ;;
-      --no-color)
-        # shellcheck disable=SC2034
-        BASHUNIT_NO_COLOR=true
-        ;;
-      -h|--help)
-        bashunit::console_header::print_bench_help
-        exit 0
-        ;;
-      *)
-        raw_args+=("$1")
-        ;;
+    -f | --filter)
+      filter="$2"
+      shift
+      ;;
+    -s | --simple)
+      export BASHUNIT_SIMPLE_OUTPUT=true
+      ;;
+    --detailed)
+      export BASHUNIT_SIMPLE_OUTPUT=false
+      ;;
+    -e | --env | --boot)
+      # Support: --env "bootstrap.sh arg1 arg2"
+      local boot_file="${2%% *}"
+      local boot_args="${2#* }"
+      if [[ "$boot_args" != "$2" ]]; then
+        export BASHUNIT_BOOTSTRAP_ARGS="$boot_args"
+      fi
+      # Export all variables from the env file so they're available in subshells
+      # (e.g., process substitution used in load_test_files)
+      set -o allexport
+      # shellcheck disable=SC1090,SC2086
+      source "$boot_file" ${BASHUNIT_BOOTSTRAP_ARGS:-}
+      set +o allexport
+      shift
+      ;;
+    -vvv | --verbose)
+      export BASHUNIT_VERBOSE=true
+      ;;
+    --skip-env-file)
+      export BASHUNIT_SKIP_ENV_FILE=true
+      ;;
+    -l | --login)
+      export BASHUNIT_LOGIN_SHELL=true
+      ;;
+    --no-color)
+      # shellcheck disable=SC2034
+      BASHUNIT_NO_COLOR=true
+      ;;
+    -h | --help)
+      bashunit::console_header::print_bench_help
+      exit 0
+      ;;
+    *)
+      raw_args[raw_args_count]="$1"
+      raw_args_count=$((raw_args_count + 1))
+      ;;
     esac
     shift
   done
 
   # Expand positional arguments
-  if [[ ${#raw_args[@]} -gt 0 ]]; then
-    for arg in "${raw_args[@]}"; do
+  if [[ "$raw_args_count" -gt 0 ]]; then
+    local arg file
+    for arg in "${raw_args[@]+"${raw_args[@]}"}"; do
       while IFS= read -r file; do
-        args+=("$file")
+        args[args_count]="$file"
+        args_count=$((args_count + 1))
       done < <(bashunit::helper::find_files_recursive "$arg" '*[bB]ench.sh')
     done
   fi
@@ -312,7 +340,12 @@ function bashunit::main::cmd_bench() {
 
   set +euo pipefail
 
-  bashunit::main::exec_benchmarks "$filter" "${args[@]}"
+  # Bash 3.0 compatible: only pass args if we have files
+  if [[ "$args_count" -gt 0 ]]; then
+    bashunit::main::exec_benchmarks "$filter" "${args[@]}"
+  else
+    bashunit::main::exec_benchmarks "$filter"
+  fi
 }
 
 #############################
@@ -381,12 +414,12 @@ function bashunit::main::is_assertion_function() {
 function bashunit::main::is_exit_code_assertion() {
   local name="$1"
   case "$name" in
-    exit_code|successful_code|unsuccessful_code|general_error|command_not_found)
-      return 0
-      ;;
-    *)
-      return 1
-      ;;
+  exit_code | successful_code | unsuccessful_code | general_error | command_not_found)
+    return 0
+    ;;
+  *)
+    return 1
+    ;;
   esac
 }
 
@@ -429,16 +462,21 @@ function bashunit::main::cmd_assert() {
 #############################
 function bashunit::main::exec_tests() {
   local filter=$1
-  local files=("${@:2}")
+  shift
 
-  local test_files=()
-  while IFS= read -r line; do
-    test_files+=("$line")
-  done < <(bashunit::helper::load_test_files "$filter" "${files[@]}")
+  # Bash 3.0 compatible: collect files into array
+  local test_files
+  local test_files_count=0
+  local _line
+  while IFS= read -r _line; do
+    [[ -z "$_line" ]] && continue
+    test_files[test_files_count]="$_line"
+    test_files_count=$((test_files_count + 1))
+  done < <(bashunit::helper::load_test_files "$filter" "$@")
 
-  bashunit::internal_log "exec_tests" "filter:$filter" "files:${test_files[*]}"
+  bashunit::internal_log "exec_tests" "filter:$filter" "files:${test_files[*]:-}"
 
-  if [[ ${#test_files[@]} -eq 0 || -z "${test_files[0]}" ]]; then
+  if [[ "$test_files_count" -eq 0 ]]; then
     printf "%sError: At least one file path is required.%s\n" "${_BASHUNIT_COLOR_FAILED}" "${_BASHUNIT_COLOR_DEFAULT}"
     bashunit::console_header::print_help
     exit 1
@@ -482,7 +520,7 @@ function bashunit::main::exec_tests() {
   fi
 
   if bashunit::parallel::is_enabled && bashunit::parallel::must_stop_on_failure; then
-    printf "\r%sStop on failure enabled...%s\n"  "${_BASHUNIT_COLOR_SKIPPED}" "${_BASHUNIT_COLOR_DEFAULT}"
+    printf "\r%sStop on failure enabled...%s\n" "${_BASHUNIT_COLOR_SKIPPED}" "${_BASHUNIT_COLOR_DEFAULT}"
   fi
 
   bashunit::console_results::print_failing_tests_and_reset
@@ -534,16 +572,21 @@ function bashunit::main::exec_tests() {
 
 function bashunit::main::exec_benchmarks() {
   local filter=$1
-  local files=("${@:2}")
+  shift
 
-  local bench_files=()
-  while IFS= read -r line; do
-    bench_files+=("$line")
-  done < <(bashunit::helper::load_bench_files "$filter" "${files[@]}")
+  # Bash 3.0 compatible: collect files into array
+  local bench_files
+  local bench_files_count=0
+  local _line
+  while IFS= read -r _line; do
+    [[ -z "$_line" ]] && continue
+    bench_files[bench_files_count]="$_line"
+    bench_files_count=$((bench_files_count + 1))
+  done < <(bashunit::helper::load_bench_files "$filter" "$@")
 
-  bashunit::internal_log "exec_benchmarks" "filter:$filter" "files:${bench_files[*]}"
+  bashunit::internal_log "exec_benchmarks" "filter:$filter" "files:${bench_files[*]:-}"
 
-  if [[ ${#bench_files[@]} -eq 0 || -z "${bench_files[0]}" ]]; then
+  if [[ "$bench_files_count" -eq 0 ]]; then
     printf "%sError: At least one file path is required.%s\n" "${_BASHUNIT_COLOR_FAILED}" "${_BASHUNIT_COLOR_DEFAULT}"
     bashunit::console_header::print_help
     exit 1
@@ -571,7 +614,7 @@ function bashunit::main::cleanup() {
 }
 
 function bashunit::main::handle_stop_on_failure_sync() {
-  printf "\n%sStop on failure enabled...%s\n"  "${_BASHUNIT_COLOR_SKIPPED}" "${_BASHUNIT_COLOR_DEFAULT}"
+  printf "\n%sStop on failure enabled...%s\n" "${_BASHUNIT_COLOR_SKIPPED}" "${_BASHUNIT_COLOR_DEFAULT}"
   bashunit::console_results::print_failing_tests_and_reset
   bashunit::console_results::print_incomplete_tests_and_reset
   bashunit::console_results::print_skipped_tests_and_reset
@@ -585,21 +628,23 @@ function bashunit::main::handle_stop_on_failure_sync() {
 
 function bashunit::main::exec_assert() {
   local original_assert_fn=$1
-  local args=("${@:2}")
+  local -a args=()
+  local args_count=$(($# - 1))
+  [[ $# -gt 1 ]] && args=("${@:2}")
 
   local assert_fn=$original_assert_fn
 
   # Check if the function exists
-  if ! type "$assert_fn" > /dev/null 2>&1; then
+  if ! type "$assert_fn" >/dev/null 2>&1; then
     assert_fn="assert_$assert_fn"
-    if ! type "$assert_fn" > /dev/null 2>&1; then
+    if ! type "$assert_fn" >/dev/null 2>&1; then
       echo "Function $original_assert_fn does not exist." 1>&2
       exit 127
     fi
   fi
 
   # Get the last argument safely by calculating the array length
-  local last_index=$((${#args[@]} - 1))
+  local last_index=$((args_count - 1))
   local last_arg="${args[$last_index]}"
   local output=""
   local inner_exit_code=0
@@ -607,16 +652,16 @@ function bashunit::main::exec_assert() {
 
   # Handle different assert_* functions
   case "$assert_fn" in
-    assert_exit_code)
-      output=$(bashunit::main::handle_assert_exit_code "$last_arg")
-      inner_exit_code=$?
-      # Remove the last argument and append the exit code
-      args=("${args[@]:0:last_index}")
-      args+=("$inner_exit_code")
-      ;;
-    *)
-      # Add more cases here for other assert_* handlers if needed
-      ;;
+  assert_exit_code)
+    output=$(bashunit::main::handle_assert_exit_code "$last_arg")
+    inner_exit_code=$?
+    # Remove the last argument and append the exit code
+    args=("${args[@]:0:last_index}")
+    args[last_index]="$inner_exit_code"
+    ;;
+  *)
+    # Add more cases here for other assert_* handlers if needed
+    ;;
   esac
 
   if [[ -n "$output" ]]; then
@@ -649,7 +694,8 @@ function bashunit::main::handle_assert_exit_code() {
     last_line=$(echo "$output" | tail -n 1)
     if echo "$last_line" | grep -q 'inner_exit_code:[0-9]*'; then
       inner_exit_code=$(echo "$last_line" | grep -o 'inner_exit_code:[0-9]*' | cut -d':' -f2)
-      if ! [[ $inner_exit_code =~ ^[0-9]+$ ]]; then
+      local _re='^[0-9]+$'
+      if ! [[ "$inner_exit_code" =~ $_re ]]; then
         inner_exit_code=1
       fi
       output=$(echo "$output" | sed '$d')
diff --git a/src/math.sh b/src/math.sh
index 67a86489..8c0e6d2a 100644
--- a/src/math.sh
+++ b/src/math.sh
@@ -20,6 +20,6 @@ function bashunit::math::calculate() {
   # Remove leading zeros from integers
   expr=$(echo "$expr" | sed -E 's/\b0*([1-9][0-9]*)/\1/g')
 
-  local result=$(( expr ))
+  local result=$((expr))
   echo "$result"
 }
diff --git a/src/parallel.sh b/src/parallel.sh
index cf172339..c0949638 100755
--- a/src/parallel.sh
+++ b/src/parallel.sh
@@ -2,6 +2,7 @@
 
 function bashunit::parallel::aggregate_test_results() {
   local temp_dir_parallel_test_suite=$1
+  local IFS=$' \t\n'
 
   bashunit::internal_log "aggregate_test_results" "dir:$temp_dir_parallel_test_suite"
 
@@ -11,9 +12,12 @@ function bashunit::parallel::aggregate_test_results() {
   local total_incomplete=0
   local total_snapshot=0
 
+  local script_dir=""
   for script_dir in "$temp_dir_parallel_test_suite"/*; do
     shopt -s nullglob
-    local result_files=("$script_dir"/*.result)
+    # Bash 3.0 compatible: separate declaration and assignment for arrays
+    local result_files
+    result_files=("$script_dir"/*.result)
     shopt -u nullglob
 
     if [ ${#result_files[@]} -eq 0 ]; then
@@ -21,27 +25,34 @@ function bashunit::parallel::aggregate_test_results() {
       continue
     fi
 
-    for result_file in "${result_files[@]}"; do
+    local result_file=""
+    for result_file in "${result_files[@]+"${result_files[@]}"}"; do
       local result_line
-      result_line=$(tail -n 1 < "$result_file")
+      result_line=$(tail -n 1 <"$result_file")
 
       local failed="${result_line##*##ASSERTIONS_FAILED=}"
-      failed="${failed%%##*}"; failed=${failed:-0}
+      failed="${failed%%##*}"
+      failed=${failed:-0}
 
       local passed="${result_line##*##ASSERTIONS_PASSED=}"
-      passed="${passed%%##*}"; passed=${passed:-0}
+      passed="${passed%%##*}"
+      passed=${passed:-0}
 
       local skipped="${result_line##*##ASSERTIONS_SKIPPED=}"
-      skipped="${skipped%%##*}"; skipped=${skipped:-0}
+      skipped="${skipped%%##*}"
+      skipped=${skipped:-0}
 
       local incomplete="${result_line##*##ASSERTIONS_INCOMPLETE=}"
-      incomplete="${incomplete%%##*}"; incomplete=${incomplete:-0}
+      incomplete="${incomplete%%##*}"
+      incomplete=${incomplete:-0}
 
       local snapshot="${result_line##*##ASSERTIONS_SNAPSHOT=}"
-      snapshot="${snapshot%%##*}"; snapshot=${snapshot:-0}
+      snapshot="${snapshot%%##*}"
+      snapshot=${snapshot:-0}
 
       local exit_code="${result_line##*##TEST_EXIT_CODE=}"
-      exit_code="${exit_code%%##*}"; exit_code=${exit_code:-0}
+      exit_code="${exit_code%%##*}"
+      exit_code=${exit_code:-0}
 
       # Add to the total counts
       total_failed=$((total_failed + failed))
@@ -115,7 +126,7 @@ function bashunit::parallel::is_enabled() {
   bashunit::internal_log "bashunit::parallel::is_enabled" \
     "requested:$BASHUNIT_PARALLEL_RUN" "os:${_BASHUNIT_OS:-Unknown}"
 
-  if bashunit::env::is_parallel_run_enabled && \
+  if bashunit::env::is_parallel_run_enabled &&
     (bashunit::check_os::is_macos || bashunit::check_os::is_ubuntu || bashunit::check_os::is_windows); then
     return 0
   fi
diff --git a/src/reports.sh b/src/reports.sh
index 6ce49716..98e3c822 100755
--- a/src/reports.sh
+++ b/src/reports.sh
@@ -37,11 +37,11 @@ function bashunit::reports::add_test() {
   local assertions="$4"
   local status="$5"
 
-  _BASHUNIT_REPORTS_TEST_FILES+=("$file")
-  _BASHUNIT_REPORTS_TEST_NAMES+=("$test_name")
-  _BASHUNIT_REPORTS_TEST_STATUSES+=("$status")
-  _BASHUNIT_REPORTS_TEST_ASSERTIONS+=("$assertions")
-  _BASHUNIT_REPORTS_TEST_DURATIONS+=("$duration")
+  _BASHUNIT_REPORTS_TEST_FILES[${#_BASHUNIT_REPORTS_TEST_FILES[@]}]="$file"
+  _BASHUNIT_REPORTS_TEST_NAMES[${#_BASHUNIT_REPORTS_TEST_NAMES[@]}]="$test_name"
+  _BASHUNIT_REPORTS_TEST_STATUSES[${#_BASHUNIT_REPORTS_TEST_STATUSES[@]}]="$status"
+  _BASHUNIT_REPORTS_TEST_ASSERTIONS[${#_BASHUNIT_REPORTS_TEST_ASSERTIONS[@]}]="$assertions"
+  _BASHUNIT_REPORTS_TEST_DURATIONS[${#_BASHUNIT_REPORTS_TEST_DURATIONS[@]}]="$duration"
 }
 
 function bashunit::reports::generate_junit_xml() {
@@ -62,12 +62,13 @@ function bashunit::reports::generate_junit_xml() {
     echo "             skipped=\"$tests_skipped\" snapshot=\"$tests_snapshot\""
     echo "             time=\"$time\">"
 
+    local i
     for i in "${!_BASHUNIT_REPORTS_TEST_NAMES[@]}"; do
-      local file="${_BASHUNIT_REPORTS_TEST_FILES[$i]}"
-      local name="${_BASHUNIT_REPORTS_TEST_NAMES[$i]}"
-      local assertions="${_BASHUNIT_REPORTS_TEST_ASSERTIONS[$i]}"
-      local status="${_BASHUNIT_REPORTS_TEST_STATUSES[$i]}"
-      local test_time="${_BASHUNIT_REPORTS_TEST_DURATIONS[$i]}"
+      local file="${_BASHUNIT_REPORTS_TEST_FILES[$i]:-}"
+      local name="${_BASHUNIT_REPORTS_TEST_NAMES[$i]:-}"
+      local assertions="${_BASHUNIT_REPORTS_TEST_ASSERTIONS[$i]:-}"
+      local status="${_BASHUNIT_REPORTS_TEST_STATUSES[$i]:-}"
+      local test_time="${_BASHUNIT_REPORTS_TEST_DURATIONS[$i]:-}"
 
       echo "    <testcase file=\"$file\""
       echo "        name=\"$name\""
@@ -79,7 +80,7 @@ function bashunit::reports::generate_junit_xml() {
 
     echo "  </testsuite>"
     echo "</testsuites>"
-  } > "$output_file"
+  } >"$output_file"
 }
 
 function bashunit::reports::generate_report_html() {
@@ -96,15 +97,16 @@ function bashunit::reports::generate_report_html() {
   local temp_file="temp_test_cases.txt"
 
   # Collect test cases by file
-  : > "$temp_file"  # Clear temp file if it exists
+  : >"$temp_file" # Clear temp file if it exists
+  local i
   for i in "${!_BASHUNIT_REPORTS_TEST_NAMES[@]}"; do
-    local file="${_BASHUNIT_REPORTS_TEST_FILES[$i]}"
-    local name="${_BASHUNIT_REPORTS_TEST_NAMES[$i]}"
-    local status="${_BASHUNIT_REPORTS_TEST_STATUSES[$i]}"
-    local test_time="${_BASHUNIT_REPORTS_TEST_DURATIONS[$i]}"
+    local file="${_BASHUNIT_REPORTS_TEST_FILES[$i]:-}"
+    local name="${_BASHUNIT_REPORTS_TEST_NAMES[$i]:-}"
+    local status="${_BASHUNIT_REPORTS_TEST_STATUSES[$i]:-}"
+    local test_time="${_BASHUNIT_REPORTS_TEST_DURATIONS[$i]:-}"
     local test_case="$file|$name|$status|$test_time"
 
-    echo "$test_case" >> "$temp_file"
+    echo "$test_case" >>"$temp_file"
   done
 
   {
@@ -156,6 +158,7 @@ function bashunit::reports::generate_report_html() {
 
     # Read the temporary file and group by file
     local current_file=""
+    local file name status test_time
     while IFS='|' read -r file name status test_time; do
       if [ "$file" != "$current_file" ]; then
         if [ -n "$current_file" ]; then
@@ -179,7 +182,7 @@ function bashunit::reports::generate_report_html() {
       echo "        <td>$status</td>"
       echo "        <td>$test_time</td>"
       echo "      </tr>"
-    done < "$temp_file"
+    done <"$temp_file"
 
     # Close the last table
     if [ -n "$current_file" ]; then
@@ -189,7 +192,7 @@ function bashunit::reports::generate_report_html() {
 
     echo "</body>"
     echo "</html>"
-  } > "$output_file"
+  } >"$output_file"
 
   # Clean up temporary file
   rm -f "$temp_file"
diff --git a/src/runner.sh b/src/runner.sh
index 3105bfa2..f7fa3ffb 100755
--- a/src/runner.sh
+++ b/src/runner.sh
@@ -3,9 +3,9 @@
 
 # Pre-compiled regex pattern for parsing test result assertions
 if [[ -z ${_BASHUNIT_RUNNER_PARSE_RESULT_REGEX+x} ]]; then
-  declare -r _BASHUNIT_RUNNER_PARSE_RESULT_REGEX='ASSERTIONS_FAILED=([0-9]*)##ASSERTIONS_PASSED=([0-9]*)##'\
-'ASSERTIONS_SKIPPED=([0-9]*)##ASSERTIONS_INCOMPLETE=([0-9]*)##ASSERTIONS_SNAPSHOT=([0-9]*)##'\
-'TEST_EXIT_CODE=([0-9]*)'
+  declare -r _BASHUNIT_RUNNER_PARSE_RESULT_REGEX='ASSERTIONS_FAILED=([0-9]*)##'\
+'ASSERTIONS_PASSED=([0-9]*)##ASSERTIONS_SKIPPED=([0-9]*)##'\
+'ASSERTIONS_INCOMPLETE=([0-9]*)##ASSERTIONS_SNAPSHOT=([0-9]*)##TEST_EXIT_CODE=([0-9]*)'
 fi
 
 function bashunit::runner::restore_workdir() {
@@ -15,8 +15,11 @@ function bashunit::runner::restore_workdir() {
 function bashunit::runner::load_test_files() {
   local filter=$1
   shift
-  local files=("${@}")
-  local scripts_ids=()
+  local IFS=$' \t\n'
+  local -a files
+  files=("$@")
+  local -a scripts_ids=()
+  local scripts_ids_count=0
 
   # Initialize coverage tracking if enabled
   if bashunit::env::is_coverage_enabled; then
@@ -27,13 +30,15 @@ function bashunit::runner::load_test_files() {
     bashunit::coverage::init
   fi
 
-  for test_file in "${files[@]}"; do
+  local test_file
+  for test_file in "${files[@]+"${files[@]}"}"; do
     if [[ ! -f $test_file ]]; then
       continue
     fi
     unset BASHUNIT_CURRENT_TEST_ID
     export BASHUNIT_CURRENT_SCRIPT_ID="$(bashunit::helper::generate_id "${test_file}")"
-    scripts_ids+=("${BASHUNIT_CURRENT_SCRIPT_ID}")
+    scripts_ids[scripts_ids_count]="${BASHUNIT_CURRENT_SCRIPT_ID}"
+    scripts_ids_count=$((scripts_ids_count + 1))
     bashunit::internal_log "Loading file" "$test_file"
     # shellcheck source=/dev/null
     source "$test_file"
@@ -60,9 +65,12 @@ function bashunit::runner::load_test_files() {
       local filtered_functions
       filtered_functions=$(bashunit::helper::get_functions_to_run "test" "$filter" "$_BASHUNIT_CACHED_ALL_FUNCTIONS")
       if [[ -n "$filtered_functions" ]]; then
+        # Bash 3.0 compatible: separate declaration and assignment for arrays
+        local functions_to_run
         # shellcheck disable=SC2206
-        local functions_to_run=($filtered_functions)
+        functions_to_run=($filtered_functions)
         local additional_failures=$((${#functions_to_run[@]} - 1))
+        local i
         for ((i = 0; i < additional_failures; i++)); do
           bashunit::state::add_tests_failed
         done
@@ -96,7 +104,8 @@ function bashunit::runner::load_test_files() {
     # Kill the spinner once the aggregation finishes
     disown "$spinner_pid" && kill "$spinner_pid" &>/dev/null
     printf "\r  \r" # Clear the spinner output
-    for script_id in "${scripts_ids[@]}"; do
+    local script_id
+    for script_id in "${scripts_ids[@]+"${scripts_ids[@]}"}"; do
       export BASHUNIT_CURRENT_SCRIPT_ID="${script_id}"
       bashunit::cleanup_script_temp_files
     done
@@ -106,9 +115,12 @@ function bashunit::runner::load_test_files() {
 function bashunit::runner::load_bench_files() {
   local filter=$1
   shift
-  local files=("${@}")
+  local IFS=$' \t\n'
+  local -a files
+  files=("$@")
 
-  for bench_file in "${files[@]}"; do
+  local bench_file
+  for bench_file in ${files+"${files[@]}"}; do
     [[ -f $bench_file ]] || continue
     unset BASHUNIT_CURRENT_TEST_ID
     export BASHUNIT_CURRENT_SCRIPT_ID="$(bashunit::helper::generate_id "${bench_file}")"
@@ -125,9 +137,12 @@ function bashunit::runner::load_bench_files() {
       local filtered_functions
       filtered_functions=$(bashunit::helper::get_functions_to_run "bench" "$filter" "$_BASHUNIT_CACHED_ALL_FUNCTIONS")
       if [[ -n "$filtered_functions" ]]; then
+        # Bash 3.0 compatible: separate declaration and assignment for arrays
+        local functions_to_run
         # shellcheck disable=SC2206
-        local functions_to_run=($filtered_functions)
+        functions_to_run=($filtered_functions)
         local additional_failures=$((${#functions_to_run[@]} - 1))
+        local i
         for ((i = 0; i < additional_failures; i++)); do
           bashunit::state::add_tests_failed
         done
@@ -166,7 +181,8 @@ function bashunit::runner::spinner() {
   local delay=0.1
   local spin_chars="|/-\\"
   while true; do
-    for ((i=0; i<${#spin_chars}; i++)); do
+    local i
+    for ((i = 0; i < ${#spin_chars}; i++)); do
       printf "\r%s" "${spin_chars:$i:1}"
       sleep "$delay"
     done
@@ -191,93 +207,112 @@ function bashunit::runner::parse_data_provider_args() {
   local input="$1"
   local current_arg=""
   local in_quotes=false
+  local had_quotes=false # Track if arg was quoted (to preserve empty quoted strings)
   local quote_char=""
   local escaped=false
-  local i
-  local arg
+  local IFS=$' \t\n'
+  local i=0
+  local arg=""
   local encoded_arg
   local -a args=()
+  local args_count=0
 
   # Check for shell metacharacters that would break eval or cause globbing
   local has_metachar=false
-  if [[ "$input" =~ [^\\][\|\&\;\*] ]] || [[ "$input" =~ ^[\|\&\;\*] ]]; then
+  local _re1='[^\\][\|\&\;\*]'
+  local _re2='^[\|\&\;\*]'
+  if [[ "$input" =~ $_re1 ]] || [[ "$input" =~ $_re2 ]]; then
     has_metachar=true
   fi
 
   # Try eval first (needed for $'...' from printf '%q'), unless metacharacters present
-  if [[ "$has_metachar" == false ]] && eval "args=($input)" 2>/dev/null && [[ ${#args[@]} -gt 0 ]]; then
-    # Successfully parsed - remove sentinel if present
-    local last_idx=$((${#args[@]} - 1))
-    if [[ -z "${args[$last_idx]}" ]]; then
-      unset 'args[$last_idx]'
+  if [[ "$has_metachar" == false ]] && eval "args=($input)" 2>/dev/null; then
+    # Check if args has elements after eval
+    args_count=0
+    local _tmp arg
+    for _tmp in ${args+"${args[@]}"}; do args_count=$((args_count + 1)); done
+    if [[ "$args_count" -gt 0 ]]; then
+      # Successfully parsed - remove sentinel if present
+      local last_idx=$((args_count - 1))
+      if [[ -z "${args[$last_idx]}" ]]; then
+        unset 'args[$last_idx]'
+      fi
+      # Print args and return early
+      for arg in "${args[@]+"${args[@]}"}"; do
+        encoded_arg="$(bashunit::helper::encode_base64 "${arg}")"
+        printf '%s\n' "$encoded_arg"
+      done
+      return
     fi
-    # Print args and return early
-    for arg in "${args[@]}"; do
-      encoded_arg="$(bashunit::helper::encode_base64 "${arg}")"
-      printf '%s\n' "$encoded_arg"
-    done
-    return
   fi
 
   # Fallback: parse args from the input string into an array, respecting quotes and escapes
-  for ((i=0; i<${#input}; i++)); do
+  local i
+  for ((i = 0; i < ${#input}; i++)); do
     local char="${input:$i:1}"
     if [ "$escaped" = true ]; then
       case "$char" in
-        t) current_arg+=$'\t' ;;
-        n) current_arg+=$'\n' ;;
-        *) current_arg+="$char" ;;
+      t) current_arg="$current_arg"$'\t' ;;
+      n) current_arg="$current_arg"$'\n' ;;
+      *) current_arg="$current_arg$char" ;;
       esac
       escaped=false
     elif [ "$char" = "\\" ]; then
       escaped=true
     elif [ "$in_quotes" = false ]; then
       case "$char" in
-        "$")
-          # Handle $'...' syntax
-          if [[ "${input:$i:2}" == "$'" ]]; then
-            in_quotes=true
-            quote_char="'"
-            # Skip the $
-            i=$((i + 1))
-          else
-            current_arg+="$char"
-          fi
-          ;;
-        "'" | '"')
+      "$")
+        # Handle $'...' syntax
+        if [[ "${input:$i:2}" == "$'" ]]; then
           in_quotes=true
-          quote_char="$char"
-          ;;
-        " " | $'\t')
-          # Only add non-empty arguments to avoid duplicates from consecutive separators
-          if [[ -n "$current_arg" ]]; then
-            args+=("$current_arg")
-          fi
-          current_arg=""
-          ;;
-        *)
-          current_arg+="$char"
-          ;;
+          had_quotes=true
+          quote_char="'"
+          # Skip the $
+          i=$((i + 1))
+        else
+          current_arg="$current_arg$char"
+        fi
+        ;;
+      "'" | '"')
+        in_quotes=true
+        had_quotes=true
+        quote_char="$char"
+        ;;
+      " " | $'\t')
+        # Add if non-empty OR if was quoted (to preserve empty quoted strings like '')
+        if [[ -n "$current_arg" || "$had_quotes" == true ]]; then
+          args[args_count]="$current_arg"
+          args_count=$((args_count + 1))
+        fi
+        current_arg=""
+        had_quotes=false
+        ;;
+      *)
+        current_arg="$current_arg$char"
+        ;;
       esac
     elif [ "$char" = "$quote_char" ]; then
       in_quotes=false
       quote_char=""
     else
-      current_arg+="$char"
+      current_arg="$current_arg$char"
     fi
   done
-  args+=("$current_arg")
+  args[args_count]="$current_arg"
+  args_count=$((args_count + 1))
   # Remove all trailing empty strings
-  while [[ ${#args[@]} -gt 0 ]]; do
-    local last_idx=$((${#args[@]} - 1))
+  while [[ "$args_count" -gt 0 ]]; do
+    local last_idx=$((args_count - 1))
     if [[ -z "${args[$last_idx]}" ]]; then
       unset 'args[$last_idx]'
+      args_count=$((args_count - 1))
     else
       break
     fi
   done
   # Print one arg per line to stdout, base64-encoded to preserve newlines in the data
-  for arg in "${args[@]+"${args[@]}"}"; do
+  local arg
+  for arg in ${args+"${args[@]}"}; do
     encoded_arg="$(bashunit::helper::encode_base64 "${arg}")"
     printf '%s\n' "$encoded_arg"
   done
@@ -286,62 +321,90 @@ function bashunit::runner::parse_data_provider_args() {
 function bashunit::runner::call_test_functions() {
   local script="$1"
   local filter="$2"
+  local IFS=$' \t\n'
   local prefix="test"
   # Use cached function names for better performance
   local filtered_functions
   filtered_functions=$(bashunit::helper::get_functions_to_run \
     "$prefix" "$filter" "$_BASHUNIT_CACHED_ALL_FUNCTIONS")
-  # shellcheck disable=SC2207
-  local functions_to_run=($(bashunit::runner::functions_for_script "$script" "$filtered_functions"))
-
-  if [[ "${#functions_to_run[@]}" -le 0 ]]; then
+  local -a functions_to_run=()
+  local functions_to_run_count=0
+  local _fn
+  while IFS= read -r _fn; do
+    [[ -z "$_fn" ]] && continue
+    functions_to_run[functions_to_run_count]="$_fn"
+    functions_to_run_count=$((functions_to_run_count + 1))
+  done < <(bashunit::runner::functions_for_script "$script" "$filtered_functions")
+
+  if [[ "$functions_to_run_count" -le 0 ]]; then
     return
   fi
 
   bashunit::helper::check_duplicate_functions "$script" || true
 
-  for fn_name in "${functions_to_run[@]}"; do
+  local -a provider_data=()
+  local provider_data_count=0
+  local -a parsed_data=()
+  local parsed_data_count=0
+
+  for fn_name in "${functions_to_run[@]+"${functions_to_run[@]}"}"; do
     if bashunit::parallel::is_enabled && bashunit::parallel::must_stop_on_failure; then
       break
     fi
 
-    local provider_data=()
+    provider_data=()
+    provider_data_count=0
+    local line
     while IFS=" " read -r line; do
-      provider_data+=("$line")
-    done <<< "$(bashunit::helper::get_provider_data "$fn_name" "$script")"
+      [[ -z "$line" ]] && continue
+      provider_data[provider_data_count]="$line"
+      provider_data_count=$((provider_data_count + 1))
+    done <<<"$(bashunit::helper::get_provider_data "$fn_name" "$script")"
 
     # No data provider found
-    if [[ "${#provider_data[@]}" -eq 0 ]]; then
+    if [[ "$provider_data_count" -eq 0 ]]; then
       bashunit::runner::run_test "$script" "$fn_name"
-      unset fn_name
+      unset -v fn_name
       continue
     fi
 
     # Execute the test function for each line of data
-    for data in "${provider_data[@]}"; do
-      local parsed_data=()
+    local data
+    for data in "${provider_data[@]+"${provider_data[@]}"}"; do
+      parsed_data=()
+      parsed_data_count=0
+      local line
       while IFS= read -r line; do
-        parsed_data+=( "$(bashunit::helper::decode_base64 "${line}")" )
-      done <<< "$(bashunit::runner::parse_data_provider_args "$data")"
-      bashunit::runner::run_test "$script" "$fn_name" "${parsed_data[@]}"
+        [[ -z "$line" ]] && continue
+        parsed_data[parsed_data_count]="$(bashunit::helper::decode_base64 "${line}")"
+        parsed_data_count=$((parsed_data_count + 1))
+      done <<<"$(bashunit::runner::parse_data_provider_args "$data")"
+      bashunit::runner::run_test "$script" "$fn_name" ${parsed_data+"${parsed_data[@]}"}
     done
-    unset fn_name
+    unset -v fn_name
   done
 }
 
 function bashunit::runner::call_bench_functions() {
   local script="$1"
   local filter="$2"
+  local IFS=$' \t\n'
   local prefix="bench"
 
   # Use cached function names for better performance
   local filtered_functions
   filtered_functions=$(bashunit::helper::get_functions_to_run \
     "$prefix" "$filter" "$_BASHUNIT_CACHED_ALL_FUNCTIONS")
-  # shellcheck disable=SC2207
-  local functions_to_run=($(bashunit::runner::functions_for_script "$script" "$filtered_functions"))
-
-  if [[ "${#functions_to_run[@]}" -le 0 ]]; then
+  local -a functions_to_run=()
+  local functions_to_run_count=0
+  local _fn
+  while IFS= read -r _fn; do
+    [[ -z "$_fn" ]] && continue
+    functions_to_run[functions_to_run_count]="$_fn"
+    functions_to_run_count=$((functions_to_run_count + 1))
+  done < <(bashunit::runner::functions_for_script "$script" "$filtered_functions")
+
+  if [[ "$functions_to_run_count" -le 0 ]]; then
     return
   fi
 
@@ -349,10 +412,11 @@ function bashunit::runner::call_bench_functions() {
     bashunit::runner::render_running_file_header "$script"
   fi
 
-  for fn_name in "${functions_to_run[@]}"; do
-    read -r revs its max_ms <<< "$(bashunit::benchmark::parse_annotations "$fn_name" "$script")"
+  local fn_name
+  for fn_name in "${functions_to_run[@]+"${functions_to_run[@]}"}"; do
+    read -r revs its max_ms <<<"$(bashunit::benchmark::parse_annotations "$fn_name" "$script")"
     bashunit::benchmark::run_function "$fn_name" "$revs" "$its" "$max_ms"
-    unset fn_name
+    unset -v fn_name
   done
 
   if ! bashunit::env::is_simple_output_enabled; then
@@ -431,7 +495,7 @@ function bashunit::runner::run_test() {
 
   local test_execution_result=$(
     # shellcheck disable=SC2064
-    trap 'exit_code=$?; bashunit::runner::cleanup_on_exit "$test_file" "$exit_code"' EXIT
+    trap "exit_code=\$?; bashunit::runner::cleanup_on_exit \"$test_file\" \"\$exit_code\"" EXIT
     bashunit::state::initialize_assertions_count
 
     # Source login shell profiles if enabled
@@ -503,9 +567,9 @@ function bashunit::runner::run_test() {
     local line="${subshell_output#*]}"  # Remove everything before and including "]"
 
     # Replace [type] with a newline to split the messages
-    line="${line//\[failed\]/$'\n'}"       # Replace [failed] with newline
-    line="${line//\[skipped\]/$'\n'}"      # Replace [skipped] with newline
-    line="${line//\[incomplete\]/$'\n'}"   # Replace [incomplete] with newline
+    line=${line//\[failed\]/$'\n'}     # Replace [failed] with newline
+    line=${line//\[skipped\]/$'\n'}    # Replace [skipped] with newline
+    line=${line//\[incomplete\]/$'\n'} # Replace [incomplete] with newline
 
     if ! bashunit::env::is_failures_only_enabled; then
       bashunit::state::print_line "$type" "$line"
@@ -517,15 +581,16 @@ function bashunit::runner::run_test() {
   local runtime_output="${test_execution_result%%##ASSERTIONS_*}"
 
   local runtime_error=""
+  local error=""
   for error in "command not found" "unbound variable" "permission denied" \
-      "no such file or directory" "syntax error" "bad substitution" \
-      "division by 0" "cannot allocate memory" "bad file descriptor" \
-      "segmentation fault" "illegal option" "argument list too long" \
-      "readonly variable" "missing keyword" "killed" \
-      "cannot execute binary file" "invalid arithmetic operator"; do
+    "no such file or directory" "syntax error" "bad substitution" \
+    "division by 0" "cannot allocate memory" "bad file descriptor" \
+    "segmentation fault" "illegal option" "argument list too long" \
+    "readonly variable" "missing keyword" "killed" \
+    "cannot execute binary file" "invalid arithmetic operator"; do
     if [[ "$runtime_output" == *"$error"* ]]; then
-      runtime_error="${runtime_output#*: }"      # Remove everything up to and including ": "
-      runtime_error="${runtime_error//$'\n'/}"   # Remove all newlines using parameter expansion
+      runtime_error="${runtime_output#*: }"  # Remove everything up to and including ": "
+      runtime_error=${runtime_error//$'\n'/} # Remove all newlines using parameter expansion
       break
     fi
   done
@@ -680,10 +745,12 @@ function bashunit::runner::parse_result() {
   shift
   local execution_result=$1
   shift
-  local args=("$@")
+  local IFS=$' \t\n'
+  local -a args
+  args=("$@")
 
   if bashunit::parallel::is_enabled; then
-    bashunit::runner::parse_result_parallel "$fn_name" "$execution_result" "${args[@]}"
+    bashunit::runner::parse_result_parallel "$fn_name" "$execution_result" ${args+"${args[@]}"}
   else
     bashunit::runner::parse_result_sync "$fn_name" "$execution_result"
   fi
@@ -694,7 +761,9 @@ function bashunit::runner::parse_result_parallel() {
   shift
   local execution_result=$1
   shift
-  local args=("$@")
+  local IFS=$' \t\n'
+  local -a args
+  args=("$@")
 
   local test_suite_dir="${TEMP_DIR_PARALLEL_TEST_SUITE}/$(basename "$test_file" .sh)"
   mkdir -p "$test_suite_dir"
@@ -721,7 +790,7 @@ function bashunit::runner::parse_result_parallel() {
 
   bashunit::runner::parse_result_sync "$fn_name" "$execution_result"
 
-  echo "$execution_result" > "$unique_test_result_file"
+  echo "$execution_result" >"$unique_test_result_file"
 }
 
 # shellcheck disable=SC2295
@@ -740,7 +809,7 @@ function bashunit::runner::parse_result_sync() {
   local test_exit_code=0
 
   # Use pre-compiled regex constant
-  if [[ $result_line =~ $_BASHUNIT_RUNNER_PARSE_RESULT_REGEX ]]; then
+  if [[ "$result_line" =~ $_BASHUNIT_RUNNER_PARSE_RESULT_REGEX ]]; then
     assertions_failed="${BASH_REMATCH[1]}"
     assertions_passed="${BASH_REMATCH[2]}"
     assertions_skipped="${BASH_REMATCH[3]}"
@@ -751,12 +820,12 @@ function bashunit::runner::parse_result_sync() {
 
   bashunit::internal_log "[SYNC]" "fn_name:$fn_name" "execution_result:$execution_result"
 
-  ((_BASHUNIT_ASSERTIONS_PASSED += assertions_passed)) || true
-  ((_BASHUNIT_ASSERTIONS_FAILED += assertions_failed)) || true
-  ((_BASHUNIT_ASSERTIONS_SKIPPED += assertions_skipped)) || true
-  ((_BASHUNIT_ASSERTIONS_INCOMPLETE += assertions_incomplete)) || true
-  ((_BASHUNIT_ASSERTIONS_SNAPSHOT += assertions_snapshot)) || true
-  ((_BASHUNIT_TEST_EXIT_CODE += test_exit_code)) || true
+  _BASHUNIT_ASSERTIONS_PASSED=$((_BASHUNIT_ASSERTIONS_PASSED + assertions_passed))
+  _BASHUNIT_ASSERTIONS_FAILED=$((_BASHUNIT_ASSERTIONS_FAILED + assertions_failed))
+  _BASHUNIT_ASSERTIONS_SKIPPED=$((_BASHUNIT_ASSERTIONS_SKIPPED + assertions_skipped))
+  _BASHUNIT_ASSERTIONS_INCOMPLETE=$((_BASHUNIT_ASSERTIONS_INCOMPLETE + assertions_incomplete))
+  _BASHUNIT_ASSERTIONS_SNAPSHOT=$((_BASHUNIT_ASSERTIONS_SNAPSHOT + assertions_snapshot))
+  _BASHUNIT_TEST_EXIT_CODE=$((_BASHUNIT_TEST_EXIT_CODE + test_exit_code))
 
   bashunit::internal_log "result_summary" \
     "failed:$assertions_failed" \
@@ -786,7 +855,7 @@ function bashunit::runner::write_failure_result_output() {
     output_section="\n    Output:\n$raw_output"
   fi
 
-  echo -e "$test_nr) $test_file:$line_number\n$error_msg$output_section" >> "$FAILURES_OUTPUT_PATH"
+  echo -e "$test_nr) $test_file:$line_number\n$error_msg$output_section" >>"$FAILURES_OUTPUT_PATH"
 }
 
 function bashunit::runner::write_skipped_result_output() {
@@ -802,7 +871,7 @@ function bashunit::runner::write_skipped_result_output() {
     test_nr=$(bashunit::state::get_tests_skipped)
   fi
 
-  echo -e "$test_nr) $test_file:$line_number\n$output_msg" >> "$SKIPPED_OUTPUT_PATH"
+  echo -e "$test_nr) $test_file:$line_number\n$output_msg" >>"$SKIPPED_OUTPUT_PATH"
 }
 
 function bashunit::runner::write_incomplete_result_output() {
@@ -818,7 +887,7 @@ function bashunit::runner::write_incomplete_result_output() {
     test_nr=$(bashunit::state::get_tests_incomplete)
   fi
 
-  echo -e "$test_nr) $test_file:$line_number\n$output_msg" >> "$INCOMPLETE_OUTPUT_PATH"
+  echo -e "$test_nr) $test_file:$line_number\n$output_msg" >>"$INCOMPLETE_OUTPUT_PATH"
 }
 
 function bashunit::runner::record_file_hook_failure() {
@@ -877,9 +946,10 @@ function bashunit::runner::execute_file_hook() {
 
   if [[ -f "$hook_output_file" ]]; then
     hook_output=""
+    local line
     while IFS= read -r line; do
       [[ -z "$hook_output" ]] && hook_output="$line" || hook_output="$hook_output"$'\n'"$line"
-    done < "$hook_output_file"
+    done <"$hook_output_file"
     rm -f "$hook_output_file"
   fi
 
@@ -967,9 +1037,10 @@ function bashunit::runner::execute_test_hook() {
 
   if [[ -f "$hook_output_file" ]]; then
     hook_output=""
+    local line
     while IFS= read -r line; do
       [[ -z "$hook_output" ]] && hook_output="$line" || hook_output="$hook_output"$'\n'"$line"
-    done < "$hook_output_file"
+    done <"$hook_output_file"
     rm -f "$hook_output_file"
   fi
 
@@ -1008,8 +1079,13 @@ function bashunit::runner::record_test_hook_failure() {
 }
 
 function bashunit::runner::clear_mocks() {
+  if [ "${#_BASHUNIT_MOCKED_FUNCTIONS[@]}" -eq 0 ]; then
+    return
+  fi
+
+  local i
   for i in "${!_BASHUNIT_MOCKED_FUNCTIONS[@]}"; do
-    bashunit::unmock "${_BASHUNIT_MOCKED_FUNCTIONS[$i]}"
+    bashunit::unmock "${_BASHUNIT_MOCKED_FUNCTIONS[$i]:-}"
   done
 }
 
@@ -1020,10 +1096,10 @@ function bashunit::runner::run_tear_down_after_script() {
   # Check if hook exists first
   if ! declare -F "tear_down_after_script" >/dev/null 2>&1; then
     # Add blank line after tests if no tear_down hook
-    if ! bashunit::env::is_simple_output_enabled && \
-        ! bashunit::env::is_failures_only_enabled && \
-        ! bashunit::env::is_no_progress_enabled && \
-        ! bashunit::parallel::is_enabled; then
+    if ! bashunit::env::is_simple_output_enabled &&
+      ! bashunit::env::is_failures_only_enabled &&
+      ! bashunit::env::is_no_progress_enabled &&
+      ! bashunit::parallel::is_enabled; then
       echo ""
     fi
     return 0
@@ -1047,10 +1123,10 @@ function bashunit::runner::run_tear_down_after_script() {
   fi
 
   # Add blank line after tear_down output
-  if ! bashunit::env::is_simple_output_enabled && \
-      ! bashunit::env::is_failures_only_enabled && \
-      ! bashunit::env::is_no_progress_enabled && \
-      ! bashunit::parallel::is_enabled; then
+  if ! bashunit::env::is_simple_output_enabled &&
+    ! bashunit::env::is_failures_only_enabled &&
+    ! bashunit::env::is_no_progress_enabled &&
+    ! bashunit::parallel::is_enabled; then
     echo ""
   fi
 
diff --git a/src/state.sh b/src/state.sh
index b869e83c..c78cae17 100644
--- a/src/state.sh
+++ b/src/state.sh
@@ -126,7 +126,7 @@ function bashunit::state::set_file_with_duplicated_function_names() {
 }
 
 function bashunit::state::add_test_output() {
-  _BASHUNIT_TEST_OUTPUT+="$1"
+  _BASHUNIT_TEST_OUTPUT="$_BASHUNIT_TEST_OUTPUT$1"
 }
 
 function bashunit::state::get_test_exit_code() {
@@ -186,7 +186,7 @@ function bashunit::state::reset_test_hook_message() {
 }
 
 function bashunit::state::is_assertion_failed_in_test() {
-  (( _BASHUNIT_ASSERTION_FAILED_IN_TEST ))
+  ((_BASHUNIT_ASSERTION_FAILED_IN_TEST))
 }
 
 function bashunit::state::mark_assertion_failed_in_test() {
@@ -200,16 +200,16 @@ function bashunit::state::set_duplicated_functions_merged() {
 }
 
 function bashunit::state::initialize_assertions_count() {
-    _BASHUNIT_ASSERTIONS_PASSED=0
-    _BASHUNIT_ASSERTIONS_FAILED=0
-    _BASHUNIT_ASSERTIONS_SKIPPED=0
-    _BASHUNIT_ASSERTIONS_INCOMPLETE=0
-    _BASHUNIT_ASSERTIONS_SNAPSHOT=0
-    _BASHUNIT_TEST_OUTPUT=""
-    _BASHUNIT_TEST_TITLE=""
-    _BASHUNIT_TEST_HOOK_FAILURE=""
-    _BASHUNIT_TEST_HOOK_MESSAGE=""
-    _BASHUNIT_ASSERTION_FAILED_IN_TEST=0
+  _BASHUNIT_ASSERTIONS_PASSED=0
+  _BASHUNIT_ASSERTIONS_FAILED=0
+  _BASHUNIT_ASSERTIONS_SKIPPED=0
+  _BASHUNIT_ASSERTIONS_INCOMPLETE=0
+  _BASHUNIT_ASSERTIONS_SNAPSHOT=0
+  _BASHUNIT_TEST_OUTPUT=""
+  _BASHUNIT_TEST_TITLE=""
+  _BASHUNIT_TEST_HOOK_FAILURE=""
+  _BASHUNIT_TEST_HOOK_MESSAGE=""
+  _BASHUNIT_ASSERTION_FAILED_IN_TEST=0
 }
 
 function bashunit::state::export_subshell_context() {
@@ -240,8 +240,7 @@ function bashunit::state::export_subshell_context() {
 ##TEST_HOOK_FAILURE=$_BASHUNIT_TEST_HOOK_FAILURE\
 ##TEST_HOOK_MESSAGE=$encoded_test_hook_message\
 ##TEST_TITLE=$encoded_test_title\
-##TEST_OUTPUT=$encoded_test_output\
-##
+##TEST_OUTPUT=$encoded_test_output##
 EOF
 }
 
@@ -252,8 +251,9 @@ function bashunit::state::calculate_total_assertions() {
   local numbers
   numbers=$(echo "$input" | grep -oE '##ASSERTIONS_\w+=[0-9]+' | grep -oE '[0-9]+')
 
+  local number
   for number in $numbers; do
-    ((total += number))
+    total=$((total + number))
   done
 
   echo $total
@@ -279,21 +279,21 @@ function bashunit::state::print_line() {
 
   local char
   case "$type" in
-    successful)       char="." ;;
-    failure)          char="${_BASHUNIT_COLOR_FAILED}F${_BASHUNIT_COLOR_DEFAULT}" ;;
-    failed)           char="${_BASHUNIT_COLOR_FAILED}F${_BASHUNIT_COLOR_DEFAULT}" ;;
-    failed_snapshot)  char="${_BASHUNIT_COLOR_FAILED}F${_BASHUNIT_COLOR_DEFAULT}" ;;
-    skipped)          char="${_BASHUNIT_COLOR_SKIPPED}S${_BASHUNIT_COLOR_DEFAULT}" ;;
-    incomplete)       char="${_BASHUNIT_COLOR_INCOMPLETE}I${_BASHUNIT_COLOR_DEFAULT}" ;;
-    snapshot)         char="${_BASHUNIT_COLOR_SNAPSHOT}N${_BASHUNIT_COLOR_DEFAULT}" ;;
-    error)            char="${_BASHUNIT_COLOR_FAILED}E${_BASHUNIT_COLOR_DEFAULT}" ;;
-    *)                char="?" && bashunit::log "warning" "unknown test type '$type'" ;;
+  successful) char="." ;;
+  failure) char="${_BASHUNIT_COLOR_FAILED}F${_BASHUNIT_COLOR_DEFAULT}" ;;
+  failed) char="${_BASHUNIT_COLOR_FAILED}F${_BASHUNIT_COLOR_DEFAULT}" ;;
+  failed_snapshot) char="${_BASHUNIT_COLOR_FAILED}F${_BASHUNIT_COLOR_DEFAULT}" ;;
+  skipped) char="${_BASHUNIT_COLOR_SKIPPED}S${_BASHUNIT_COLOR_DEFAULT}" ;;
+  incomplete) char="${_BASHUNIT_COLOR_INCOMPLETE}I${_BASHUNIT_COLOR_DEFAULT}" ;;
+  snapshot) char="${_BASHUNIT_COLOR_SNAPSHOT}N${_BASHUNIT_COLOR_DEFAULT}" ;;
+  error) char="${_BASHUNIT_COLOR_FAILED}E${_BASHUNIT_COLOR_DEFAULT}" ;;
+  *) char="?" && bashunit::log "warning" "unknown test type '$type'" ;;
   esac
 
   if bashunit::parallel::is_enabled; then
-      printf "%s" "$char"
+    printf "%s" "$char"
   else
-    if (( _BASHUNIT_TOTAL_TESTS_COUNT % 50 == 0 )); then
+    if ((_BASHUNIT_TOTAL_TESTS_COUNT % 50 == 0)); then
       printf "%s\n" "$char"
     else
       printf "%s" "$char"
diff --git a/src/str.sh b/src/str.sh
index a30c919a..d8ccae62 100644
--- a/src/str.sh
+++ b/src/str.sh
@@ -12,7 +12,7 @@ function bashunit::str::rpad() {
   local width_padding="${3:-$TERMINAL_WIDTH}"
   # Subtract 1 more to account for the extra space
   local padding=$((width_padding - ${#right_word} - 1))
-  if (( padding < 0 )); then
+  if ((padding < 0)); then
     padding=0
   fi
 
@@ -39,14 +39,14 @@ function bashunit::str::rpad() {
     # If the current character is part of an ANSI sequence, skip it and copy it
     if [[ "$original_char" == $'\x1b' ]]; then
       while [[ "${left_text:$j:1}" != "m" && $j -lt ${#left_text} ]]; do
-        result_left_text+="${left_text:$j:1}"
+        result_left_text="$result_left_text${left_text:$j:1}"
         ((j++))
       done
-      result_left_text+="${left_text:$j:1}"  # Append the final 'm'
+      result_left_text="$result_left_text${left_text:$j:1}" # Append the final 'm'
       ((j++))
     elif [[ "$char" == "$original_char" ]]; then
       # Match the actual character
-      result_left_text+="$char"
+      result_left_text="$result_left_text$char"
       ((i++))
       ((j++))
     else
@@ -55,14 +55,14 @@ function bashunit::str::rpad() {
   done
 
   local remaining_space
-  if $is_truncated ; then
-    result_left_text+="..."
+  if $is_truncated; then
+    result_left_text="$result_left_text..."
     # 1: due to a blank space
     # 3: due to the appended ...
     remaining_space=$((width_padding - ${#clean_left_text} - ${#right_word} - 1 - 3))
   else
     # Copy any remaining characters after the truncation point
-    result_left_text+="${left_text:$j}"
+    result_left_text="$result_left_text${left_text:$j}"
     remaining_space=$((width_padding - ${#clean_left_text} - ${#right_word} - 1))
   fi
 
diff --git a/src/test_doubles.sh b/src/test_doubles.sh
index fa199b2f..2ea30e26 100644
--- a/src/test_doubles.sh
+++ b/src/test_doubles.sh
@@ -5,8 +5,13 @@ declare -a _BASHUNIT_MOCKED_FUNCTIONS=()
 function bashunit::unmock() {
   local command=$1
 
+  if [ "${#_BASHUNIT_MOCKED_FUNCTIONS[@]}" -eq 0 ]; then
+    return
+  fi
+
+  local i
   for i in "${!_BASHUNIT_MOCKED_FUNCTIONS[@]}"; do
-    if [[ "${_BASHUNIT_MOCKED_FUNCTIONS[$i]}" == "$command" ]]; then
+    if [[ "${_BASHUNIT_MOCKED_FUNCTIONS[$i]:-}" == "$command" ]]; then
       unset "_BASHUNIT_MOCKED_FUNCTIONS[$i]"
       unset -f "$command"
       local variable
@@ -34,7 +39,7 @@ function bashunit::mock() {
 
   export -f "${command?}"
 
-  _BASHUNIT_MOCKED_FUNCTIONS+=("$command")
+  _BASHUNIT_MOCKED_FUNCTIONS[${#_BASHUNIT_MOCKED_FUNCTIONS[@]}]="$command"
 }
 
 function bashunit::spy() {
@@ -46,8 +51,8 @@ function bashunit::spy() {
   local test_id="${BASHUNIT_CURRENT_TEST_ID:-global}"
   times_file=$(bashunit::temp_file "${test_id}_${variable}_times")
   params_file=$(bashunit::temp_file "${test_id}_${variable}_params")
-  echo 0 > "$times_file"
-  : > "$params_file"
+  echo 0 >"$times_file"
+  : >"$params_file"
   export "${variable}_times_file"="$times_file"
   export "${variable}_params_file"="$params_file"
 
@@ -56,7 +61,7 @@ function bashunit::spy() {
     local serialized=\"\"
     local arg
     for arg in \"\$@\"; do
-      serialized+=\"\$(printf '%q' \"\$arg\")$'\\x1f'\"
+      serialized=\"\$serialized\$(printf '%q' \"\$arg\")$'\\x1f'\"
     done
     serialized=\${serialized%$'\\x1f'}
     printf '%s\x1e%s\\n' \"\$raw\" \"\$serialized\" >> '$params_file'
@@ -68,7 +73,7 @@ function bashunit::spy() {
 
   export -f "${command?}"
 
-  _BASHUNIT_MOCKED_FUNCTIONS+=("$command")
+  _BASHUNIT_MOCKED_FUNCTIONS[${#_BASHUNIT_MOCKED_FUNCTIONS[@]}]="$command"
 }
 
 function assert_have_been_called() {
@@ -96,7 +101,8 @@ function assert_have_been_called_with() {
   shift
 
   local index=""
-  if [[ ${!#} =~ ^[0-9]+$ ]]; then
+  local _re='^[0-9]+$'
+  if [[ "${!#}" =~ $_re ]]; then
     index=${!#}
     set -- "${@:1:$#-1}"
   fi
diff --git a/tests/acceptance/bashunit_direct_fn_call_test.sh b/tests/acceptance/bashunit_direct_fn_call_test.sh
index b66633ac..5ba1e63c 100644
--- a/tests/acceptance/bashunit_direct_fn_call_test.sh
+++ b/tests/acceptance/bashunit_direct_fn_call_test.sh
@@ -4,7 +4,7 @@ set -euo pipefail
 function set_up_before_script() {
   TEST_ENV_FILE="tests/acceptance/fixtures/.env.default"
   TEST_MULTILINE_STR="first line
-  \n
+\n
 four line
 find me with \n a regular expression"
 }
@@ -78,8 +78,10 @@ function test_bashunit_direct_fn_call_failure() {
   local expected="foo"
   local actual="bar"
 
-  assert_match_snapshot "$(./bashunit --no-parallel -a assert_same --env "$TEST_ENV_FILE" "$expected" $actual 2>&1)"
-  assert_general_error "$(./bashunit --no-parallel -a assert_same --env "$TEST_ENV_FILE" "$expected" $actual)"
+  assert_match_snapshot \
+    "$(./bashunit --no-parallel -a assert_same --env "$TEST_ENV_FILE" "$expected" $actual 2>&1)"
+  assert_general_error \
+    "$(./bashunit --no-parallel -a assert_same --env "$TEST_ENV_FILE" "$expected" $actual)"
 }
 
 function test_bashunit_direct_fn_call_non_existing_fn() {
@@ -91,7 +93,7 @@ function test_bashunit_direct_fn_call_non_existing_fn() {
 function test_bashunit_assert_exit_code_successful_with_inner_func() {
   local temp=$(mktemp)
   # shellcheck disable=SC2116
-  local output="$(./bashunit --no-parallel -a exit_code "0" "$(echo "unknown command")" 2> "$temp")"
+  local output="$(./bashunit --no-parallel -a exit_code "0" "$(echo "unknown command")" 2>"$temp")"
 
   assert_empty "$output"
   assert_file_contains "$temp" "Command not found: unknown command"
@@ -103,7 +105,7 @@ function test_bashunit_assert_exit_code_error_with_inner_func() {
   local no_color_flag=""
   bashunit::env::is_no_color_enabled && no_color_flag="--no-color"
   # shellcheck disable=SC2116,SC2086
-  local output="$(./bashunit --no-parallel $no_color_flag -a exit_code "1" "$(echo "unknown command")" 2> "$temp")"
+  local output="$(./bashunit --no-parallel $no_color_flag -a exit_code "1" "$(echo "unknown command")" 2>"$temp")"
 
   assert_empty "$output"
 
@@ -127,7 +129,7 @@ function test_bashunit_assert_exit_code_str_successful_but_exit_code_error() {
   local no_color_flag=""
   bashunit::env::is_no_color_enabled && no_color_flag="--no-color"
   # shellcheck disable=SC2086
-  local output="$(./bashunit --no-parallel $no_color_flag -a exit_code "1" "echo something to stdout" 2> "$temp")"
+  local output="$(./bashunit --no-parallel $no_color_flag -a exit_code "1" "echo something to stdout" 2>"$temp")"
 
   assert_same "something to stdout" "$output"
 
@@ -138,7 +140,7 @@ function test_bashunit_assert_exit_code_str_successful_but_exit_code_error() {
 # shellcheck disable=SC2155
 function test_bashunit_assert_exit_code_str_successful_and_exit_code_ok() {
   local temp=$(mktemp)
-  local output="$(./bashunit --no-parallel -a exit_code "0" "echo something to stdout" 2> "$temp")"
+  local output="$(./bashunit --no-parallel -a exit_code "0" "echo something to stdout" 2>"$temp")"
 
   assert_same "something to stdout" "$output"
   assert_empty "$(cat "$temp")"
diff --git a/tests/acceptance/bashunit_fail_test.sh b/tests/acceptance/bashunit_fail_test.sh
index 8afabb43..c49e6467 100644
--- a/tests/acceptance/bashunit_fail_test.sh
+++ b/tests/acceptance/bashunit_fail_test.sh
@@ -21,7 +21,8 @@ function test_bashunit_when_a_test_fail_verbose_output_option() {
 }
 
 function test_different_verbose_snapshots_matches() {
-  bashunit::todo "The different snapshots for these tests should also be identical, option to choose snapshot name?"
+  bashunit::todo \
+    "The different snapshots for these tests should also be identical, option to choose snapshot name?"
 }
 
 function test_bashunit_when_a_test_fail_simple_output_env() {
@@ -53,5 +54,6 @@ function test_bashunit_with_a_test_fail_and_exit_immediately() {
 }
 
 function test_different_simple_snapshots_matches() {
-  bashunit::todo "The different snapshots for these tests should also be identical, option to choose snapshot name?"
+  bashunit::todo \
+    "The different snapshots for these tests should also be identical, option to choose snapshot name?"
 }
diff --git a/tests/acceptance/bashunit_init_test.sh b/tests/acceptance/bashunit_init_test.sh
index b2649296..40ea6d3e 100644
--- a/tests/acceptance/bashunit_init_test.sh
+++ b/tests/acceptance/bashunit_init_test.sh
@@ -17,7 +17,7 @@ function test_bashunit_init_creates_structure() {
   # switch into a clean temporary directory
   pushd "$TMP_DIR" >/dev/null
   # generate test scaffolding
-  "$BASHUNIT_PATH" init > /tmp/init.log
+  "$BASHUNIT_PATH" init >/tmp/init.log
   # perform the assertions
   assert_file_exists "tests/example_test.sh"
   assert_file_exists "tests/bootstrap.sh"
@@ -27,7 +27,7 @@ function test_bashunit_init_creates_structure() {
 
 function test_bashunit_init_custom_directory() {
   pushd "$TMP_DIR" >/dev/null
-  "$BASHUNIT_PATH" init custom > /tmp/init.log
+  "$BASHUNIT_PATH" init custom >/tmp/init.log
   assert_file_exists "custom/example_test.sh"
   assert_file_exists "custom/bootstrap.sh"
   popd >/dev/null
@@ -37,8 +37,8 @@ function test_bashunit_init_updates_env() {
   bashunit::skip "flaky" && return
 
   pushd "$TMP_DIR" >/dev/null
-  echo "BASHUNIT_BOOTSTRAP=old/bootstrap.sh" > .env
-  "$BASHUNIT_PATH" init custom > /tmp/init.log
+  echo "BASHUNIT_BOOTSTRAP=old/bootstrap.sh" >.env
+  "$BASHUNIT_PATH" init custom >/tmp/init.log
   assert_file_exists "custom/example_test.sh"
   assert_file_exists "custom/bootstrap.sh"
   assert_file_contains .env "#BASHUNIT_BOOTSTRAP=old/bootstrap.sh"
diff --git a/tests/acceptance/bashunit_lifecycle_output_test.sh b/tests/acceptance/bashunit_lifecycle_output_test.sh
index fb7ab24b..10112bcc 100644
--- a/tests/acceptance/bashunit_lifecycle_output_test.sh
+++ b/tests/acceptance/bashunit_lifecycle_output_test.sh
@@ -10,33 +10,33 @@ function tear_down() {
 
 function test_lifecycle_functions_do_not_output_without_verbose() {
   local test_file="$TEST_DIR/test_lifecycle.sh"
-  cat > "$test_file" << 'EOF'
+  cat >"$test_file" <<'EOF'
 #!/usr/bin/env bash
 
 function set_up_before_script() {
-  echo "stdout from set_up_before_script"
-  echo "stderr from set_up_before_script" >&2
+echo "stdout from set_up_before_script"
+echo "stderr from set_up_before_script" >&2
 }
 
 function tear_down_after_script() {
-  echo "stdout from tear_down_after_script"
-  echo "stderr from tear_down_after_script" >&2
+echo "stdout from tear_down_after_script"
+echo "stderr from tear_down_after_script" >&2
 }
 
 function set_up() {
-  echo "stdout from set_up"
-  echo "stderr from set_up" >&2
+echo "stdout from set_up"
+echo "stderr from set_up" >&2
 }
 
 function tear_down() {
-  echo "stdout from tear_down"
-  echo "stderr from tear_down" >&2
+echo "stdout from tear_down"
+echo "stderr from tear_down" >&2
 }
 
 function test_no_verbose_example() {
-  echo "stdout from test"
-  echo "stderr from test" >&2
-  assert_same "a" "a"
+echo "stdout from test"
+echo "stderr from test" >&2
+assert_same "a" "a"
 }
 EOF
 
@@ -57,33 +57,33 @@ EOF
 
 function test_lifecycle_functions_output_with_verbose() {
   local test_file="$TEST_DIR/test_lifecycle.sh"
-  cat > "$test_file" << 'EOF'
+  cat >"$test_file" <<'EOF'
 #!/usr/bin/env bash
 
 function set_up_before_script() {
-  echo "stdout from set_up_before_script"
-  echo "stderr from set_up_before_script" >&2
+echo "stdout from set_up_before_script"
+echo "stderr from set_up_before_script" >&2
 }
 
 function tear_down_after_script() {
-  echo "stdout from tear_down_after_script"
-  echo "stderr from tear_down_after_script" >&2
+echo "stdout from tear_down_after_script"
+echo "stderr from tear_down_after_script" >&2
 }
 
 function set_up() {
-  echo "stdout from set_up"
-  echo "stderr from set_up" >&2
+echo "stdout from set_up"
+echo "stderr from set_up" >&2
 }
 
 function tear_down() {
-  echo "stdout from tear_down"
-  echo "stderr from tear_down" >&2
+echo "stdout from tear_down"
+echo "stderr from tear_down" >&2
 }
 
 function test_verbose_example() {
-  echo "stdout from test"
-  echo "stderr from test" >&2
-  assert_same "a" "a"
+echo "stdout from test"
+echo "stderr from test" >&2
+assert_same "a" "a"
 }
 EOF
 
@@ -104,19 +104,19 @@ EOF
 
 function test_hook_visibility_shows_running_message_in_normal_mode() {
   local test_file="$TEST_DIR/test_hook_visibility_normal.sh"
-  cat > "$test_file" << 'EOF'
+  cat >"$test_file" <<'EOF'
 #!/usr/bin/env bash
 
 function set_up_before_script() {
-  true
+true
 }
 
 function tear_down_after_script() {
-  true
+true
 }
 
 function test_hook_normal_mode() {
-  assert_same "foo" "foo"
+assert_same "foo" "foo"
 }
 EOF
 
@@ -130,19 +130,19 @@ EOF
 
 function test_hook_visibility_suppressed_in_failures_only_mode() {
   local test_file="$TEST_DIR/test_hook_visibility_failures.sh"
-  cat > "$test_file" << 'EOF'
+  cat >"$test_file" <<'EOF'
 #!/usr/bin/env bash
 
 function set_up_before_script() {
-  true
+true
 }
 
 function tear_down_after_script() {
-  true
+true
 }
 
 function test_hook_failures_only() {
-  assert_same "foo" "foo"
+assert_same "foo" "foo"
 }
 EOF
 
@@ -155,19 +155,19 @@ EOF
 
 function test_hook_visibility_suppressed_in_simple_mode() {
   local test_file="$TEST_DIR/test_hook_visibility_simple.sh"
-  cat > "$test_file" << 'EOF'
+  cat >"$test_file" <<'EOF'
 #!/usr/bin/env bash
 
 function set_up_before_script() {
-  true
+true
 }
 
 function tear_down_after_script() {
-  true
+true
 }
 
 function test_hook_simple_mode() {
-  assert_same "foo" "foo"
+assert_same "foo" "foo"
 }
 EOF
 
@@ -181,11 +181,11 @@ EOF
 
 function test_hook_visibility_not_shown_when_hooks_not_defined() {
   local test_file="$TEST_DIR/test_no_hooks.sh"
-  cat > "$test_file" << 'EOF'
+  cat >"$test_file" <<'EOF'
 #!/usr/bin/env bash
 
 function test_no_hooks_defined() {
-  assert_same "foo" "foo"
+assert_same "foo" "foo"
 }
 EOF
 
diff --git a/tests/acceptance/bashunit_pass_test.sh b/tests/acceptance/bashunit_pass_test.sh
index 9297f445..c151cc06 100644
--- a/tests/acceptance/bashunit_pass_test.sh
+++ b/tests/acceptance/bashunit_pass_test.sh
@@ -21,7 +21,8 @@ function test_bashunit_when_a_test_passes_verbose_output_option() {
 }
 
 function test_different_verbose_snapshots_matches() {
-  bashunit::todo "The different snapshots for these tests should also be identical, option to choose snapshot name?"
+  bashunit::todo \
+    "The different snapshots for these tests should also be identical, option to choose snapshot name?"
 }
 
 function test_bashunit_when_a_test_passes_simple_output_env() {
@@ -39,5 +40,6 @@ function test_bashunit_when_a_test_passes_simple_output_option() {
 }
 
 function test_different_simple_snapshots_matches() {
-  bashunit::todo "The different snapshots for these tests should also be identical, option to choose snapshot name?"
+  bashunit::todo \
+    "The different snapshots for these tests should also be identical, option to choose snapshot name?"
 }
diff --git a/tests/acceptance/bashunit_report_html_test.sh b/tests/acceptance/bashunit_report_html_test.sh
index 241dd5c4..ef4b4d54 100644
--- a/tests/acceptance/bashunit_report_html_test.sh
+++ b/tests/acceptance/bashunit_report_html_test.sh
@@ -9,7 +9,8 @@ function set_up_before_script() {
 function test_bashunit_when_report_html_option() {
   local test_file=./tests/acceptance/fixtures/test_bashunit_when_report_html.sh
 
-  assert_match_snapshot "$(./bashunit --no-parallel --env "$TEST_ENV_FILE" --report-html custom.html "$test_file")"
+  assert_match_snapshot \
+    "$(./bashunit --no-parallel --env "$TEST_ENV_FILE" --report-html custom.html "$test_file")"
   assert_file_exists custom.html
 
   if [[ -f custom.html ]]; then
diff --git a/tests/acceptance/bashunit_script_temp_file_cleanup_test.sh b/tests/acceptance/bashunit_script_temp_file_cleanup_test.sh
index baa7d006..6af251c0 100644
--- a/tests/acceptance/bashunit_script_temp_file_cleanup_test.sh
+++ b/tests/acceptance/bashunit_script_temp_file_cleanup_test.sh
@@ -33,7 +33,8 @@ function test_script_temp_files_are_cleaned_up_after_test_run() {
   # Check that no parallel temp files remain in the temp directory
 
   if [[ -d "$parallel_temp_base_dir" ]]; then
-    remaining_files=$(find "$parallel_temp_base_dir" -name "script_with_setup_temp_file" 2>/dev/null || true)
+    remaining_files=$(find "$parallel_temp_base_dir" \
+      -name "script_with_setup_temp_file" 2>/dev/null || true)
 
     assert_empty "$remaining_files"
 
diff --git a/tests/acceptance/bashunit_setup_before_script_error_test.sh b/tests/acceptance/bashunit_setup_before_script_error_test.sh
index 3a424148..1fa15819 100644
--- a/tests/acceptance/bashunit_setup_before_script_error_test.sh
+++ b/tests/acceptance/bashunit_setup_before_script_error_test.sh
@@ -90,7 +90,8 @@ function test_bashunit_when_set_up_before_script_fails_with_multiple_tests() {
 
 function test_bashunit_when_set_up_before_script_with_intermediate_failing_command() {
   local test_file
-  test_file=./tests/acceptance/fixtures/test_bashunit_when_setup_before_script_with_intermediate_failing_command.sh
+  test_file=./tests/acceptance/fixtures/\
+test_bashunit_when_setup_before_script_with_intermediate_failing_command.sh
   local fixture=$test_file
 
   local header_line="Running $fixture"
diff --git a/tests/acceptance/bashunit_show_output_on_failure_test.sh b/tests/acceptance/bashunit_show_output_on_failure_test.sh
index 0d99d8ce..59dcef0e 100644
--- a/tests/acceptance/bashunit_show_output_on_failure_test.sh
+++ b/tests/acceptance/bashunit_show_output_on_failure_test.sh
@@ -32,7 +32,7 @@ function test_show_output_on_failure_disabled_via_env() {
   local actual
   actual="$(
     BASHUNIT_SHOW_OUTPUT_ON_FAILURE=false \
-    ./bashunit --no-parallel --env "$TEST_ENV_FILE" "$test_file" 2>&1 || true
+      ./bashunit --no-parallel --env "$TEST_ENV_FILE" "$test_file" 2>&1 || true
   )"
 
   assert_not_contains "Output:" "$actual"
@@ -45,7 +45,7 @@ function test_show_output_flag_overrides_env() {
   local actual
   actual="$(
     BASHUNIT_SHOW_OUTPUT_ON_FAILURE=false \
-    ./bashunit --no-parallel --env "$TEST_ENV_FILE" --show-output "$test_file" 2>&1 || true
+      ./bashunit --no-parallel --env "$TEST_ENV_FILE" --show-output "$test_file" 2>&1 || true
   )"
 
   assert_contains "Output:" "$actual"
diff --git a/tests/acceptance/bashunit_stop_on_failure_test.sh b/tests/acceptance/bashunit_stop_on_failure_test.sh
index ff55b0bd..8c922d1e 100644
--- a/tests/acceptance/bashunit_stop_on_failure_test.sh
+++ b/tests/acceptance/bashunit_stop_on_failure_test.sh
@@ -21,7 +21,8 @@ function test_bashunit_when_stop_on_failure_env() {
 }
 
 function test_different_snapshots_matches() {
-  bashunit::todo "The different snapshots for these tests should also be identical, option to choose snapshot name?"
+  bashunit::todo \
+    "The different snapshots for these tests should also be identical, option to choose snapshot name?"
 }
 
 function test_bashunit_when_stop_on_failure_env_simple_output() {
diff --git a/tests/acceptance/bashunit_teardown_after_script_error_test.sh b/tests/acceptance/bashunit_teardown_after_script_error_test.sh
index cc870c96..9562717d 100644
--- a/tests/acceptance/bashunit_teardown_after_script_error_test.sh
+++ b/tests/acceptance/bashunit_teardown_after_script_error_test.sh
@@ -63,7 +63,8 @@ function test_bashunit_when_tear_down_after_script_with_failing_command() {
 
 function test_bashunit_when_tear_down_after_script_with_intermediate_failing_command() {
   local test_file
-  test_file=./tests/acceptance/fixtures/test_bashunit_when_teardown_after_script_with_intermediate_failing_command.sh
+  test_file=./tests/acceptance/fixtures/\
+test_bashunit_when_teardown_after_script_with_intermediate_failing_command.sh
   local fixture=$test_file
 
   local header_line="Running $fixture"
diff --git a/tests/acceptance/bashunit_test.sh b/tests/acceptance/bashunit_test.sh
index 6840c691..fbf0b983 100644
--- a/tests/acceptance/bashunit_test.sh
+++ b/tests/acceptance/bashunit_test.sh
@@ -1,7 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-
 function test_bashunit_should_display_version() {
   local fixture
   fixture=$(printf "\e[1m\e[32mbashunit\e[0m - %s" "$BASHUNIT_VERSION")
diff --git a/tests/acceptance/bashunit_upgrade_test.sh b/tests/acceptance/bashunit_upgrade_test.sh
index 562668e5..bb0ee8c4 100644
--- a/tests/acceptance/bashunit_upgrade_test.sh
+++ b/tests/acceptance/bashunit_upgrade_test.sh
@@ -60,9 +60,8 @@ function test_upgrade_when_a_new_version_found() {
     bashunit::skip "curl or wget not installed" && return
   fi
 
-  sed -i -e \
-    's/declare -r BASHUNIT_VERSION="[0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}"/declare -r BASHUNIT_VERSION="0.1.0"/' \
-    "$TMP_BIN"
+  sed -i -e 's/declare -r BASHUNIT_VERSION="[0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}"/'\
+'declare -r BASHUNIT_VERSION="0.1.0"/' "$TMP_BIN"
 
   if [[ $_BASHUNIT_OS == "OSX" ]]; then
     rm -f "${TMP_BIN}-e"
@@ -89,9 +88,8 @@ function test_do_not_update_on_consecutive_calls() {
     bashunit::skip "curl or wget not installed" && return
   fi
 
-  sed -i -e \
-    's/declare -r BASHUNIT_VERSION="[0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}"/declare -r BASHUNIT_VERSION="0.1.0"/' \
-    "$TMP_BIN"
+  sed -i -e 's/declare -r BASHUNIT_VERSION="[0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}"/'\
+'declare -r BASHUNIT_VERSION="0.1.0"/' "$TMP_BIN"
 
   if [[ $_BASHUNIT_OS == "OSX" ]]; then
     rm -f "${TMP_BIN}-e"
diff --git a/tests/acceptance/fixtures/script_with_setup_temp_file.sh b/tests/acceptance/fixtures/script_with_setup_temp_file.sh
index d9a3211f..b69770dd 100644
--- a/tests/acceptance/fixtures/script_with_setup_temp_file.sh
+++ b/tests/acceptance/fixtures/script_with_setup_temp_file.sh
@@ -3,8 +3,8 @@
 function set_up_before_script() {
   SCRIPT_TEMP_FILE=$(bashunit::temp_file "script-setup")
   SCRIPT_TEMP_DIR=$(bashunit::temp_dir "script-setup")
-  echo "Script temp file created: $SCRIPT_TEMP_FILE" > "$SCRIPT_TEMP_FILE"
-  echo "Script temp dir created: $SCRIPT_TEMP_DIR" > "$SCRIPT_TEMP_DIR/marker.txt"
+  echo "Script temp file created: $SCRIPT_TEMP_FILE" >"$SCRIPT_TEMP_FILE"
+  echo "Script temp dir created: $SCRIPT_TEMP_DIR" >"$SCRIPT_TEMP_DIR/marker.txt"
 }
 
 function test_simple_passing_test() {
diff --git a/tests/acceptance/install_test.sh b/tests/acceptance/install_test.sh
index 33425cff..dc7e9304 100644
--- a/tests/acceptance/install_test.sh
+++ b/tests/acceptance/install_test.sh
@@ -52,8 +52,7 @@ function test_install_downloads_the_latest_version() {
   assert_string_ends_with "$(printf "\n> bashunit has been installed in the 'lib' folder")" "$output"
   assert_file_exists "$installed_bashunit"
 
-  assert_string_starts_with\
-    "$(printf "\e[1m\e[32mbashunit\e[0m - ")"\
+  assert_string_starts_with "$(printf "\e[1m\e[32mbashunit\e[0m - ")" \
     "$("$installed_bashunit" --version)"
 }
 
@@ -74,8 +73,7 @@ function test_install_downloads_in_given_folder() {
   assert_string_ends_with "$(printf "\n> bashunit has been installed in the 'deps' folder")" "$output"
   assert_file_exists "$installed_bashunit"
 
-  assert_string_starts_with\
-    "$(printf "\e[1m\e[32mbashunit\e[0m - ")"\
+  assert_string_starts_with "$(printf "\e[1m\e[32mbashunit\e[0m - ")" \
     "$("$installed_bashunit" --version)"
 }
 
@@ -92,14 +90,15 @@ function test_install_downloads_the_given_version() {
 
   output="$(./install.sh lib 0.9.0)"
 
-  assert_same\
-    "$(printf "> Downloading a concrete version: '0.9.0'\n> bashunit has been installed in the 'lib' folder")"\
-    "$output"
+  local expected
+  expected="> Downloading a concrete version: '0.9.0'
+> bashunit has been installed in the 'lib' folder"
+
+  assert_same "$expected" "$output"
 
   assert_file_exists "$installed_bashunit"
 
-  assert_same\
-    "$(printf "\e[1m\e[32mbashunit\e[0m - 0.9.0")"\
+  assert_same "$(printf "\e[1m\e[32mbashunit\e[0m - 0.9.0")" \
     "$("$installed_bashunit" --version)"
 }
 
@@ -116,9 +115,10 @@ function test_install_downloads_the_given_version_without_dir() {
   output="$(./install.sh 0.19.0)"
 
   assert_same \
-    "$(printf "%s\n" \
-      "> Downloading a concrete version: '0.19.0'" \
-      "> bashunit has been installed in the 'lib' folder" \
+    "$(
+      printf "%s\n" \
+        "> Downloading a concrete version: '0.19.0'" \
+        "> bashunit has been installed in the 'lib' folder"
     )" \
     "$output"
 
@@ -130,6 +130,11 @@ function test_install_downloads_the_given_version_without_dir() {
 }
 
 function test_install_downloads_the_non_stable_beta_version() {
+  # Skip on Bash 3.0 - mocks don't work for external scripts
+  if [[ "${BASH_VERSINFO[0]}" -eq 3 ]] && [[ "${BASH_VERSINFO[1]}" -lt 1 ]]; then
+    bashunit::skip "Mocks don't work for external scripts in Bash 3.0"
+    return
+  fi
   if [[ "$ACTIVE_INTERNET" -eq 1 ]]; then
     bashunit::skip "no internet connection" && return
   fi
@@ -140,21 +145,23 @@ function test_install_downloads_the_non_stable_beta_version() {
     bashunit::skip "curl or wget not installed" && return
   fi
 
-  bashunit::mock date <<< "2023-11-13"
-  bashunit::mock tput <<< ""
+  bashunit::mock date <<<"2023-11-13"
+  bashunit::mock tput <<<""
   local installed_bashunit="./deps/bashunit"
   local output
 
   output="$(./install.sh deps beta)"
 
-  assert_contains\
-    "$(printf "> Downloading non-stable version: 'beta'\n> bashunit has been installed in the 'deps' folder")"\
-    "$output"
+  local expected
+  expected="> Downloading non-stable version: 'beta'
+> bashunit has been installed in the 'deps' folder"
+
+  assert_contains "$expected" "$output"
 
   assert_file_exists "$installed_bashunit"
 
-  assert_matches\
-    "$(printf "\(non-stable\) beta after ([0-9]+\.[0-9]+\.[0-9]+) \[2023-11-13\] 🐍 \#[a-fA-F0-9]{7}")"\
+  assert_matches \
+    "$(printf "\(non-stable\) beta after ([0-9]+\.[0-9]+\.[0-9]+) \[2023-11-13\] 🐍 \#[a-fA-F0-9]{7}")" \
     "$("$installed_bashunit" --version)"
 
   assert_directory_not_exists "./deps/temp_bashunit"
diff --git a/tests/bootstrap.sh b/tests/bootstrap.sh
index 369a9dd0..debee88e 100644
--- a/tests/bootstrap.sh
+++ b/tests/bootstrap.sh
@@ -2,15 +2,15 @@
 set -euo pipefail
 
 function mock_non_existing_fn() {
-  return 127;
+  return 127
 }
 
 function mock_false() {
-  return 1;
+  return 1
 }
 
 function mock_true() {
-  return 0;
+  return 0
 }
 
 function mock_unknown_linux_os() {
@@ -23,7 +23,6 @@ function mock_unknown_linux_os() {
   bashunit::mock bashunit::check_os::is_windows mock_false
 }
 
-
 function mock_ubuntu_os() {
   bashunit::mock bashunit::check_os::is_linux mock_true
   bashunit::mock bashunit::check_os::is_ubuntu mock_true
diff --git a/tests/functional/custom_asserts_test.sh b/tests/functional/custom_asserts_test.sh
index 050254a0..232338ff 100644
--- a/tests/functional/custom_asserts_test.sh
+++ b/tests/functional/custom_asserts_test.sh
@@ -11,8 +11,7 @@ function test_assert_foo_passed() {
 }
 
 function test_assert_foo_failed() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Assert foo failed" "foo" "but got " "bar")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Assert foo failed" "foo" "but got " "bar")" \
     "$(assert_foo "bar")"
 }
 
@@ -21,7 +20,7 @@ function test_assert_positive_number_passed() {
 }
 
 function test_assert_positive_number_failed() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Assert positive number failed" "positive number" "got" "0")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Assert positive number failed" "positive number" "got" "0")" \
     "$(assert_positive_number "0")"
 }
diff --git a/tests/functional/doubles_test.sh b/tests/functional/doubles_test.sh
index 8b5aa2dd..773085c0 100644
--- a/tests/functional/doubles_test.sh
+++ b/tests/functional/doubles_test.sh
@@ -16,6 +16,12 @@ function test_mock_ps_when_executing_a_sourced_function() {
 }
 
 function test_spy_commands_called_when_executing_a_script() {
+  # Skip on Bash 3.0 - shell function exports don't work for external scripts
+  if [[ "${BASH_VERSINFO[0]}" -eq 3 ]] && [[ "${BASH_VERSINFO[1]}" -lt 1 ]]; then
+    bashunit::skip "Spies don't work for external scripts in Bash 3.0"
+    return
+  fi
+
   bashunit::spy ps
   bashunit::spy awk
   bashunit::spy head
@@ -41,6 +47,11 @@ function test_spy_commands_called_when_executing_a_sourced_function() {
 }
 
 function test_spy_commands_called_once_when_executing_a_script() {
+  # Skip on Bash 3.0 - shell function exports don't work for external scripts
+  if [[ "${BASH_VERSINFO[0]}" -eq 3 ]] && [[ "${BASH_VERSINFO[1]}" -lt 1 ]]; then
+    bashunit::skip "Spies don't work for external scripts in Bash 3.0"
+    return
+  fi
   # Skip when coverage is enabled because coverage uses head internally,
   # which interferes with spying on head
   if bashunit::env::is_coverage_enabled; then
diff --git a/tests/unit/assert_snapshot_test.sh b/tests/unit/assert_snapshot_test.sh
index 714261e1..165435b1 100644
--- a/tests/unit/assert_snapshot_test.sh
+++ b/tests/unit/assert_snapshot_test.sh
@@ -67,7 +67,7 @@ function test_assert_match_snapshot_with_placeholder() {
 
   local snapshot_path
   snapshot_path="$(bashunit::temp_dir)/assert_snapshot_test_sh.test_assert_match_snapshot_with_placeholder.snapshot"
-  echo 'Run at ::ignore::' > "$snapshot_path"
+  echo 'Run at ::ignore::' >"$snapshot_path"
 
   assert_empty "$(assert_match_snapshot "Run at $(date -u '+%F %T UTC')" "$snapshot_path")"
 }
@@ -79,7 +79,7 @@ function test_assert_snapshot_with_custom_placeholder() {
 
   local snapshot_path
   snapshot_path="$(bashunit::temp_dir)/assert_snapshot_test_sh.test_assert_snapshot_with_custom_placeholder.snapshot"
-  echo 'Value __ANY__' > "$snapshot_path"
+  echo 'Value __ANY__' >"$snapshot_path"
 
   export BASHUNIT_SNAPSHOT_PLACEHOLDER='__ANY__'
   assert_empty "$(assert_match_snapshot "Value 42" "$snapshot_path")"
diff --git a/tests/unit/assert_test.sh b/tests/unit/assert_test.sh
index f03ab91b..bc6857c7 100644
--- a/tests/unit/assert_test.sh
+++ b/tests/unit/assert_test.sh
@@ -8,9 +8,8 @@ function test_successful_fail() {
 }
 
 function test_unsuccessful_fail() {
-  assert_same\
-    "$(bashunit::console_results::print_failure_message \
-      "Unsuccessful fail" "Failure message")"\
+  assert_same "$(bashunit::console_results::print_failure_message \
+    "Unsuccessful fail" "Failure message")" \
     "$(bashunit::fail "Failure message")"
 }
 
@@ -27,11 +26,9 @@ function provider_successful_assert_true() {
 }
 
 function test_unsuccessful_assert_true() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert true" \
-      "true or 0" \
-      "but got " "false")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert true" \
+    "true or 0" \
+    "but got " "false")" \
     "$(assert_true false)"
 }
 
@@ -40,11 +37,9 @@ function test_successful_assert_true_on_function() {
 }
 
 function test_unsuccessful_assert_true_on_function() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert true on function"\
-      "command or function with zero exit code"\
-      "but got " "exit code: 2")" \
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert true on function" \
+    "command or function with zero exit code" \
+    "but got " "exit code: 2")" \
     "$(assert_true "eval return 2")"
 }
 
@@ -61,11 +56,9 @@ function provider_successful_assert_false() {
 }
 
 function test_unsuccessful_assert_false() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert false" \
-      "false or 1" \
-      "but got " "true")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert false" \
+    "false or 1" \
+    "but got " "true")" \
     "$(assert_false true)"
 }
 
@@ -74,11 +67,9 @@ function test_successful_assert_false_on_function() {
 }
 
 function test_unsuccessful_assert_false_on_function() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert false on function"\
-      "command or function with non-zero exit code"\
-      "but got " "exit code: 0")" \
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert false on function" \
+    "command or function with non-zero exit code" \
+    "but got " "exit code: 0")" \
     "$(assert_false "eval return 0")"
 }
 
@@ -87,8 +78,7 @@ function test_successful_assert_same() {
 }
 
 function test_unsuccessful_assert_same() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert same" "1" "but got " "2")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert same" "1" "but got " "2")" \
     "$(assert_same "1" "2")"
 }
 
@@ -97,8 +87,8 @@ function test_successful_assert_empty() {
 }
 
 function test_unsuccessful_assert_empty() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert empty" "to be empty" "but got " "1")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert empty" "to be empty" "but got " "1")" \
     "$(assert_empty "1")"
 }
 
@@ -107,8 +97,8 @@ function test_successful_assert_not_empty() {
 }
 
 function test_unsuccessful_assert_not_empty() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert not empty" "to not be empty" "but got " "")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert not empty" "to not be empty" "but got " "")" \
     "$(assert_not_empty "")"
 }
 
@@ -117,8 +107,7 @@ function test_successful_assert_not_same() {
 }
 
 function test_unsuccessful_assert_not_same() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert not same" "1" "but got " "1")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert not same" "1" "but got " "1")" \
     "$(assert_not_same "1" "1")"
 }
 
@@ -127,8 +116,7 @@ function test_successful_assert_not_equals() {
 }
 
 function test_unsuccessful_assert_not_equals() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert not equals" "1" "but got " "1")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert not equals" "1" "but got " "1")" \
     "$(assert_not_equals "1" "1")"
 }
 
@@ -136,10 +124,9 @@ function test_unsuccessful_assert_not_equals_with_special_chars() {
   local str1="${_BASHUNIT_COLOR_FAILED}✗ Failed${_BASHUNIT_COLOR_DEFAULT} foo"
   local str2="✗ Failed foo"
 
-  assert_equals\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert not equals with special chars" \
-      "$str1" "but got " "$str2")"\
+  assert_equals "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert not equals with special chars" \
+    "$str1" "but got " "$str2")" \
     "$(assert_not_equals "$str1" "$str2")"
 }
 
@@ -159,8 +146,8 @@ function test_successful_assert_contains() {
 }
 
 function test_unsuccessful_assert_contains() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert contains" "GNU/Linux" "to contain" "Unix")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert contains" "GNU/Linux" "to contain" "Unix")" \
     "$(assert_contains "Unix" "GNU/Linux")"
 }
 
@@ -180,8 +167,8 @@ function test_successful_assert_matches() {
 }
 
 function test_unsuccessful_assert_matches() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert matches" "GNU/Linux" "to match" ".*Pinux*")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert matches" "GNU/Linux" "to match" ".*Pinux*")" \
     "$(assert_matches ".*Pinux*" "GNU/Linux")"
 }
 
@@ -209,8 +196,7 @@ function test_unsuccessful_assert_exit_code() {
     exit 1
   }
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert exit code" "1" "to be" "0")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert exit code" "1" "to be" "0")" \
     "$(assert_exit_code "0" "$(fake_function)")"
 }
 
@@ -245,8 +231,8 @@ function test_unsuccessful_assert_successful_code() {
     return 2
   }
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert successful code" "2" "to be exactly" "0")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert successful code" "2" "to be exactly" "0")" \
     "$(assert_successful_code "$(fake_function)")"
 }
 
@@ -282,13 +268,13 @@ function test_unsuccessful_assert_general_error() {
     return 2
   }
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert general error" "2" "to be exactly" "1")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert general error" "2" "to be exactly" "1")" \
     "$(assert_general_error "$(fake_function)")"
 }
 
 function test_successful_assert_command_not_found() {
-  assert_empty "$(assert_command_not_found "$(a_non_existing_function > /dev/null 2>&1)")"
+  assert_empty "$(assert_command_not_found "$(a_non_existing_function >/dev/null 2>&1)")"
 }
 
 function test_unsuccessful_assert_command_not_found() {
@@ -296,8 +282,9 @@ function test_unsuccessful_assert_command_not_found() {
     return 0
   }
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert command not found" "0" "to be exactly" "127")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert command not found" "0" "to be exactly" "127")" \
     "$(assert_command_not_found "$(fake_function)")"
 }
 
@@ -323,41 +310,44 @@ function test_unsuccessful_assert_exec() {
   local expected="exit: 1"$'\n'"stdout: Expected"$'\n'"stderr: Expected error"
   local actual="exit: 0"$'\n'"stdout: out"$'\n'"stderr: err"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful assert exec" "$expected" "but got " "$actual")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert exec" "$expected" "but got " "$actual")" \
     "$(assert_exec fake_command --exit 1 --stdout "Expected" --stderr "Expected error")"
 }
 
 function test_successful_assert_array_contains() {
-  local distros=(Ubuntu 123 Linux\ Mint)
+  local distros
+  distros=(Ubuntu 123 Linux\ Mint)
 
   assert_empty "$(assert_array_contains "123" "${distros[@]}")"
 }
 
 function test_unsuccessful_assert_array_contains() {
-  local distros=(Ubuntu 123 Linux\ Mint)
-
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert array contains"\
-      "Ubuntu 123 Linux Mint"\
-      "to contain"\
-      "non_existing_element")"\
+  local distros
+  distros=(Ubuntu 123 Linux\ Mint)
+
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert array contains" \
+    "Ubuntu 123 Linux Mint" \
+    "to contain" \
+    "non_existing_element")" \
     "$(assert_array_contains "non_existing_element" "${distros[@]}")"
 }
 
 function test_successful_assert_array_not_contains() {
-  local distros=(Ubuntu 123 Linux\ Mint)
+  local distros
+  distros=(Ubuntu 123 Linux\ Mint)
 
   assert_empty "$(assert_array_not_contains "a_non_existing_element" "${distros[@]}")"
 }
 
 function test_unsuccessful_assert_array_not_contains() {
-  local distros=(Ubuntu 123 Linux\ Mint)
+  local distros
+  distros=(Ubuntu 123 Linux\ Mint)
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert array not contains" "Ubuntu 123 Linux Mint" "to not contain" "123")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert array not contains" "Ubuntu 123 Linux Mint" "to not contain" "123")" \
     "$(assert_array_not_contains "123" "${distros[@]}")"
 }
 
@@ -366,9 +356,9 @@ function test_successful_assert_string_starts_with() {
 }
 
 function test_unsuccessful_assert_string_starts_with() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert string starts with" "pause" "to start with" "hou")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert string starts with" "pause" "to start with" "hou")" \
     "$(assert_string_starts_with "hou" "pause")"
 }
 
@@ -377,9 +367,9 @@ function test_successful_assert_string_not_starts_with() {
 }
 
 function test_unsuccessful_assert_string_not_starts_with() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert string not starts with" "house" "to not start with" "ho")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert string not starts with" "house" "to not start with" "ho")" \
     "$(assert_string_not_starts_with "ho" "house")"
 }
 
@@ -388,21 +378,20 @@ function test_successful_assert_string_ends_with() {
 }
 
 function test_unsuccessful_assert_string_ends_with() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert string ends with" "foobar" "to end with" "foo")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert string ends with" "foobar" "to end with" "foo")" \
     "$(assert_string_ends_with "foo" "foobar")"
 }
 
-
 function test_successful_assert_string_not_ends_with() {
   assert_empty "$(assert_string_not_ends_with "foo" "foobar")"
 }
 
 function test_unsuccessful_assert_string_not_ends_with() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert string not ends with" "foobar" "to not end with" "bar")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert string not ends with" "foobar" "to not end with" "bar")" \
     "$(assert_string_not_ends_with "bar" "foobar")"
 }
 
@@ -412,14 +401,14 @@ function test_assert_string_start_end_with_special_chars() {
 }
 
 function test_assert_string_start_end_with_special_chars_fail() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Assert string start end with special chars fail" "fooX" "to start with" "foo.")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Assert string start end with special chars fail" "fooX" "to start with" "foo.")" \
     "$(assert_string_starts_with "foo." "fooX")"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Assert string start end with special chars fail" "fooX" "to end with" ".bar")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Assert string start end with special chars fail" "fooX" "to end with" ".bar")" \
     "$(assert_string_ends_with ".bar" "fooX")"
 }
 
@@ -428,9 +417,8 @@ function test_successful_assert_less_than() {
 }
 
 function test_unsuccessful_assert_less_than() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert less than" "3" "to be less than" "1")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert less than" "3" "to be less than" "1")" \
     "$(assert_less_than "1" "3")"
 }
 
@@ -443,9 +431,9 @@ function test_successful_assert_less_or_equal_than_with_an_equal_number() {
 }
 
 function test_unsuccessful_assert_less_or_equal_than() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert less or equal than" "3" "to be less or equal than" "1")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert less or equal than" "3" "to be less or equal than" "1")" \
     "$(assert_less_or_equal_than "1" "3")"
 }
 
@@ -454,9 +442,9 @@ function test_successful_assert_greater_than() {
 }
 
 function test_unsuccessful_assert_greater_than() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert greater than" "1" "to be greater than" "3")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert greater than" "1" "to be greater than" "3")" \
     "$(assert_greater_than "3" "1")"
 }
 
@@ -469,15 +457,14 @@ function test_successful_assert_greater_or_equal_than_with_an_equal_number() {
 }
 
 function test_unsuccessful_assert_greater_or_equal_than() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert greater or equal than" "1" "to be greater or equal than" "3")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert greater or equal than" "1" "to be greater or equal than" "3")" \
     "$(assert_greater_or_equal_than "3" "1")"
 }
 
 function test_successful_assert_equals() {
-  assert_equals\
-    "✗ Failed foo"\
+  assert_equals "✗ Failed foo" \
     "${_BASHUNIT_COLOR_FAILED}✗ Failed${_BASHUNIT_COLOR_DEFAULT} foo"
 }
 
@@ -491,12 +478,11 @@ function test_unsuccessful_assert_equals() {
   local str1="${_BASHUNIT_COLOR_FAILED}✗ Failed${_BASHUNIT_COLOR_DEFAULT} str1"
   local str2="${_BASHUNIT_COLOR_FAILED}✗ Failed${_BASHUNIT_COLOR_DEFAULT} str2"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert equals"\
-      "✗ Failed str1"\
-      "but got "\
-      "✗ Failed str2")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert equals" \
+    "✗ Failed str1" \
+    "but got " \
+    "✗ Failed str2")" \
     "$(assert_equals "$str1" "$str2")"
 }
 
@@ -531,9 +517,9 @@ function test_successful_assert_line_count_multiline_with_new_lines() {
 }
 
 function test_unsuccessful_assert_line_count() {
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert line count" "one_line_string" "to contain number of lines equal to" "10" "but found" "1")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert line count" "one_line_string" "to contain number of lines equal to" "10" "but found" "1")" \
     "$(assert_line_count 10 "one_line_string")"
 }
 
diff --git a/tests/unit/bash_version_test.sh b/tests/unit/bash_version_test.sh
index 14ef4806..22180ec0 100755
--- a/tests/unit/bash_version_test.sh
+++ b/tests/unit/bash_version_test.sh
@@ -3,7 +3,7 @@
 function test_fail_with_old_bash_version() {
   local output
   local exit_code=0
-  output=$(BASHUNIT_TEST_BASH_VERSION=3.1 ./bashunit --version 2>&1) || exit_code=$?
-  assert_contains "Bashunit requires Bash >= 3.2. Current version: 3.1" "$output"
+  output=$(BASHUNIT_TEST_BASH_VERSION=2.05 ./bashunit --version 2>&1) || exit_code=$?
+  assert_contains "Bashunit requires Bash >= 3.0. Current version: 2.05" "$output"
   assert_general_error "$output" "" "$exit_code"
 }
diff --git a/tests/unit/clock_test.sh b/tests/unit/clock_test.sh
index 3adb08c0..ba94d67a 100644
--- a/tests/unit/clock_test.sh
+++ b/tests/unit/clock_test.sh
@@ -11,7 +11,7 @@ function tear_down_after_script() {
 }
 
 function mock_non_existing_fn() {
-  return 127;
+  return 127
 }
 
 function mock_date_seconds() {
@@ -24,7 +24,7 @@ function mock_date_seconds() {
 
 function test_now_with_perl() {
   bashunit::mock bashunit::clock::shell_time mock_non_existing_fn
-  bashunit::mock perl <<< "1720705883457"
+  bashunit::mock perl <<<"1720705883457"
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
 
@@ -35,7 +35,7 @@ function test_now_on_linux_unknown() {
   mock_unknown_linux_os
   bashunit::mock bashunit::clock::shell_time mock_non_existing_fn
   bashunit::mock perl mock_non_existing_fn
-  bashunit::mock date <<< "1720705883457"
+  bashunit::mock date <<<"1720705883457"
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
 
@@ -45,7 +45,7 @@ function test_now_on_linux_unknown() {
 function test_now_on_linux_alpine() {
   mock_alpine_os
   bashunit::mock bashunit::clock::shell_time mock_non_existing_fn
-  bashunit::mock perl <<< "1720705883457"
+  bashunit::mock perl <<<"1720705883457"
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
 
@@ -56,7 +56,7 @@ function test_now_on_windows_without_with_powershell() {
   mock_windows_os
   bashunit::mock bashunit::dependencies::has_perl mock_false
   bashunit::mock bashunit::dependencies::has_powershell mock_true
-  bashunit::mock powershell <<< "1727768183281580800"
+  bashunit::mock powershell <<<"1727768183281580800"
   bashunit::mock bashunit::clock::shell_time mock_non_existing_fn
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
@@ -68,7 +68,7 @@ function test_now_on_windows_without_without_powershell() {
   mock_windows_os
   bashunit::mock bashunit::dependencies::has_perl mock_false
   bashunit::mock bashunit::dependencies::has_powershell mock_false
-  bashunit::mock date <<< "1727768951"
+  bashunit::mock date <<<"1727768951"
   bashunit::mock bashunit::clock::shell_time mock_non_existing_fn
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
@@ -94,7 +94,7 @@ function test_now_on_osx_without_perl() {
 
   mock_macos
   bashunit::mock bashunit::dependencies::has_perl mock_false
-  bashunit::mock bashunit::clock::shell_time <<< "1727708708.326957"
+  bashunit::mock bashunit::clock::shell_time <<<"1727708708.326957"
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
 
@@ -102,7 +102,7 @@ function test_now_on_osx_without_perl() {
 }
 
 function test_runtime_in_milliseconds_when_not_empty_time() {
-  bashunit::mock perl <<< "1720705883457"
+  bashunit::mock perl <<<"1720705883457"
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
 
@@ -110,8 +110,8 @@ function test_runtime_in_milliseconds_when_not_empty_time() {
 }
 
 function test_now_prefers_perl_over_shell_time() {
-  bashunit::mock bashunit::clock::shell_time <<< "1234.0"
-  bashunit::mock perl <<< "999999999999"
+  bashunit::mock bashunit::clock::shell_time <<<"1234.0"
+  bashunit::mock perl <<<"999999999999"
   bashunit::mock bashunit::dependencies::has_python mock_false
   bashunit::mock bashunit::dependencies::has_node mock_false
 
@@ -121,9 +121,9 @@ function test_now_prefers_perl_over_shell_time() {
 function test_now_prefers_python_over_node() {
   bashunit::mock perl mock_non_existing_fn
   bashunit::mock bashunit::dependencies::has_python mock_true
-  bashunit::mock python <<< "777777777777"
+  bashunit::mock python <<<"777777777777"
   bashunit::mock bashunit::dependencies::has_node mock_true
-  bashunit::mock node <<< "888888888888"
+  bashunit::mock node <<<"888888888888"
 
   assert_same "777777777777" "$(bashunit::clock::now)"
 }
diff --git a/tests/unit/console_results_test.sh b/tests/unit/console_results_test.sh
index d8337257..87597c4a 100644
--- a/tests/unit/console_results_test.sh
+++ b/tests/unit/console_results_test.sh
@@ -8,20 +8,21 @@ function set_state_value() {
 
   # Extract variable name from getter function name
   case "$getter_name" in
-    bashunit::state::get_tests_passed) var_name="_BASHUNIT_TESTS_PASSED" ;;
-    bashunit::state::get_tests_failed) var_name="_BASHUNIT_TESTS_FAILED" ;;
-    bashunit::state::get_tests_skipped) var_name="_BASHUNIT_TESTS_SKIPPED" ;;
-    bashunit::state::get_tests_incomplete) var_name="_BASHUNIT_TESTS_INCOMPLETE" ;;
-    bashunit::state::get_tests_snapshot) var_name="_BASHUNIT_TESTS_SNAPSHOT" ;;
-    bashunit::state::get_assertions_passed) var_name="_BASHUNIT_ASSERTIONS_PASSED" ;;
-    bashunit::state::get_assertions_failed) var_name="_BASHUNIT_ASSERTIONS_FAILED" ;;
-    bashunit::state::get_assertions_skipped) var_name="_BASHUNIT_ASSERTIONS_SKIPPED" ;;
-    bashunit::state::get_assertions_incomplete) var_name="_BASHUNIT_ASSERTIONS_INCOMPLETE" ;;
-    bashunit::state::get_assertions_snapshot) var_name="_BASHUNIT_ASSERTIONS_SNAPSHOT" ;;
-    bashunit::state::is_duplicated_test_functions_found) var_name="_BASHUNIT_DUPLICATED_TEST_FUNCTIONS_FOUND" ;;
-    bashunit::state::get_duplicated_function_names) var_name="_BASHUNIT_DUPLICATED_FUNCTION_NAMES" ;;
-    bashunit::state::get_file_with_duplicated_function_names)
-      var_name="_BASHUNIT_FILE_WITH_DUPLICATED_FUNCTION_NAMES" ;;
+  bashunit::state::get_tests_passed) var_name="_BASHUNIT_TESTS_PASSED" ;;
+  bashunit::state::get_tests_failed) var_name="_BASHUNIT_TESTS_FAILED" ;;
+  bashunit::state::get_tests_skipped) var_name="_BASHUNIT_TESTS_SKIPPED" ;;
+  bashunit::state::get_tests_incomplete) var_name="_BASHUNIT_TESTS_INCOMPLETE" ;;
+  bashunit::state::get_tests_snapshot) var_name="_BASHUNIT_TESTS_SNAPSHOT" ;;
+  bashunit::state::get_assertions_passed) var_name="_BASHUNIT_ASSERTIONS_PASSED" ;;
+  bashunit::state::get_assertions_failed) var_name="_BASHUNIT_ASSERTIONS_FAILED" ;;
+  bashunit::state::get_assertions_skipped) var_name="_BASHUNIT_ASSERTIONS_SKIPPED" ;;
+  bashunit::state::get_assertions_incomplete) var_name="_BASHUNIT_ASSERTIONS_INCOMPLETE" ;;
+  bashunit::state::get_assertions_snapshot) var_name="_BASHUNIT_ASSERTIONS_SNAPSHOT" ;;
+  bashunit::state::is_duplicated_test_functions_found) var_name="_BASHUNIT_DUPLICATED_TEST_FUNCTIONS_FOUND" ;;
+  bashunit::state::get_duplicated_function_names) var_name="_BASHUNIT_DUPLICATED_FUNCTION_NAMES" ;;
+  bashunit::state::get_file_with_duplicated_function_names)
+    var_name="_BASHUNIT_FILE_WITH_DUPLICATED_FUNCTION_NAMES"
+    ;;
   esac
 
   # Set the actual variable
@@ -362,10 +363,10 @@ function test_render_execution_time_on_osx_with_perl() {
   bashunit::mock bashunit::dependencies::has_adjtimex mock_false
   bashunit::mock bashunit::dependencies::has_perl mock_true
   _BASHUNIT_START_TIME="1726393394574382186"
-  bashunit::mock perl <<< "1726393394574372186"
-  bashunit::mock uname <<< "Darwin"
+  bashunit::mock perl <<<"1726393394574372186"
+  bashunit::mock uname <<<"Darwin"
   render_result=$(
-  bashunit::mock perl <<< "1726393394574372186";
+    bashunit::mock perl <<<"1726393394574372186"
 
     bashunit::console_results::render_result || true
   )
diff --git a/tests/unit/coverage_test.sh b/tests/unit/coverage_test.sh
index 878617e0..fdf1208c 100644
--- a/tests/unit/coverage_test.sh
+++ b/tests/unit/coverage_test.sh
@@ -144,7 +144,7 @@ function test_coverage_get_executable_lines_counts_correctly() {
   local temp_file
   temp_file=$(mktemp)
 
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 
 # This is a comment
@@ -359,13 +359,13 @@ function test_coverage_check_threshold_fails_when_below_minimum() {
   # Create a tracked file with some executable lines but no hits
   local temp_file
   temp_file=$(mktemp)
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 echo "line 1"
 echo "line 2"
 EOF
 
-  echo "$temp_file" > "$_BASHUNIT_COVERAGE_TRACKED_FILES"
+  echo "$temp_file" >"$_BASHUNIT_COVERAGE_TRACKED_FILES"
 
   # Capture only the exit code, suppress output
   local result
@@ -387,16 +387,16 @@ function test_coverage_report_lcov_generates_valid_format() {
   # Create a test source file
   local temp_file
   temp_file=$(mktemp)
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 echo "line 1"
 echo "line 2"
 EOF
 
-  echo "$temp_file" > "$_BASHUNIT_COVERAGE_TRACKED_FILES"
+  echo "$temp_file" >"$_BASHUNIT_COVERAGE_TRACKED_FILES"
 
   # Simulate some hits
-  echo "${temp_file}:2" >> "$_BASHUNIT_COVERAGE_DATA_FILE"
+  echo "${temp_file}:2" >>"$_BASHUNIT_COVERAGE_DATA_FILE"
 
   # Generate report to temp file
   local report_file
@@ -585,7 +585,7 @@ function test_coverage_get_tracked_files_returns_sorted_unique() {
     echo "/path/to/b.sh"
     echo "/path/to/a.sh"
     echo "/path/to/b.sh"
-  } >> "$_BASHUNIT_COVERAGE_TRACKED_FILES"
+  } >>"$_BASHUNIT_COVERAGE_TRACKED_FILES"
 
   local result
   result=$(bashunit::coverage::get_tracked_files | tr '\n' ' ')
@@ -601,7 +601,7 @@ function test_coverage_get_file_stats_returns_formatted_string() {
   # Create a test file with known content
   local temp_file
   temp_file=$(mktemp)
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 echo "line 1"
 echo "line 2"
@@ -620,7 +620,7 @@ EOF
 function test_coverage_extract_functions_finds_basic_function() {
   local temp_file
   temp_file=$(mktemp)
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 function my_func() {
   echo "hello"
@@ -638,7 +638,7 @@ EOF
 function test_coverage_extract_functions_finds_namespaced_function() {
   local temp_file
   temp_file=$(mktemp)
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 function bashunit::helper::do_thing() {
   echo "hello"
@@ -656,7 +656,7 @@ EOF
 function test_coverage_extract_functions_finds_multiple_functions() {
   local temp_file
   temp_file=$(mktemp)
-  cat > "$temp_file" << 'EOF'
+  cat >"$temp_file" <<'EOF'
 #!/usr/bin/env bash
 function func_one() {
   echo "one"
@@ -693,7 +693,7 @@ function test_coverage_get_line_hits_counts_correctly() {
     echo "${test_file}:5"
     echo "${test_file}:5"
     echo "${test_file}:5"
-  } >> "$_BASHUNIT_COVERAGE_DATA_FILE"
+  } >>"$_BASHUNIT_COVERAGE_DATA_FILE"
 
   local result
   result=$(bashunit::coverage::get_line_hits "$test_file" 5)
@@ -715,7 +715,7 @@ function test_coverage_report_text_shows_no_files_message() {
   bashunit::coverage::init
 
   # Empty tracked files
-  : > "$_BASHUNIT_COVERAGE_TRACKED_FILES"
+  : >"$_BASHUNIT_COVERAGE_TRACKED_FILES"
 
   local output
   output=$(bashunit::coverage::report_text)
diff --git a/tests/unit/custom_assertions_test.sh b/tests/unit/custom_assertions_test.sh
index 2b5a298d..df27fb61 100644
--- a/tests/unit/custom_assertions_test.sh
+++ b/tests/unit/custom_assertions_test.sh
@@ -4,7 +4,7 @@
 function _assert_valid_json() {
   local json="$1"
 
-  if ! echo "$json" | jq . > /dev/null 2>&1; then
+  if ! echo "$json" | jq . >/dev/null 2>&1; then
     bashunit::fail "Invalid json: $json"
     return
   fi
@@ -96,7 +96,7 @@ function test_custom_assertion_calling_assert_same_shows_correct_test_name() {
     }
 
     _BASHUNIT_ASSERTION_FAILED_IN_TEST=0
-    _assert_length_equals "5" "abc"  # length is 3, not 5
+    _assert_length_equals "5" "abc" # length is 3, not 5
 
     echo "$_captured_output"
   )"
@@ -145,4 +145,3 @@ function test_helper_find_test_function_name_from_deeply_nested() {
 
   assert_same "test_helper_find_test_function_name_from_deeply_nested" "$found_name"
 }
-
diff --git a/tests/unit/directory_test.sh b/tests/unit/directory_test.sh
index 1d094b6d..9f112155 100644
--- a/tests/unit/directory_test.sh
+++ b/tests/unit/directory_test.sh
@@ -10,18 +10,17 @@ function test_successful_assert_directory_exists() {
 function test_unsuccessful_assert_directory_exists() {
   local a_directory="a_random_directory_that_will_not_exist"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert directory exists" "$a_directory" "to exist but" "do not exist")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert directory exists" "$a_directory" "to exist but" "do not exist")" \
     "$(assert_directory_exists "$a_directory")"
 }
 
 function test_assert_directory_exists_should_not_work_with_files() {
   local a_file="$(bashunit::current_dir)/$(bashunit::current_filename)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Assert directory exists should not work with files" "$a_file" "to exist but" "do not exist")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Assert directory exists should not work with files" "$a_file" "to exist but" "do not exist")" \
     "$(assert_directory_exists "$a_file")"
 }
 
@@ -34,9 +33,8 @@ function test_successful_assert_directory_not_exists() {
 function test_unsuccessful_assert_directory_not_exists() {
   local a_directory="$(bashunit::current_dir)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert directory not exists" "$a_directory" "to not exist but" "the directory exists")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert directory not exists" "$a_directory" "to not exist but" "the directory exists")" \
     "$(assert_directory_not_exists "$a_directory")"
 }
 
@@ -49,18 +47,17 @@ function test_successful_assert_is_directory() {
 function test_unsuccessful_assert_is_directory() {
   local a_directory="a_random_directory_that_will_not_exist"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory" "$a_directory" "to be a directory" "but is not a directory")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory" "$a_directory" "to be a directory" "but is not a directory")" \
     "$(assert_is_directory "$a_directory")"
 }
 
 function test_unsuccessful_assert_is_directory_when_a_file_is_given() {
   local a_file="$(bashunit::current_dir)/$(bashunit::current_filename)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert is directory when a file is given" "$a_file" "to be a directory" "but is not a directory")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory when a file is given" "$a_file" "to be a directory" "but is not a directory")" \
     "$(assert_is_directory "$a_file")"
 }
 
@@ -73,9 +70,8 @@ function test_successful_assert_is_directory_empty() {
 function test_unsuccessful_assert_is_directory_empty() {
   local a_directory="$(bashunit::current_dir)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory empty" "$a_directory" "to be empty" "but is not empty")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory empty" "$a_directory" "to be empty" "but is not empty")" \
     "$(assert_is_directory_empty "$a_directory")"
 }
 
@@ -88,9 +84,8 @@ function test_successful_assert_is_directory_not_empty() {
 function test_unsuccessful_assert_is_directory_not_empty() {
   local a_directory=$(mktemp -d)
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory not empty" "$a_directory" "to not be empty" "but is empty")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory not empty" "$a_directory" "to not be empty" "but is empty")" \
     "$(assert_is_directory_not_empty "$a_directory")"
 }
 
@@ -103,10 +98,9 @@ function test_successful_assert_is_directory_readable() {
 function test_unsuccessful_assert_is_directory_readable_when_a_file_is_given() {
   local a_file="$(bashunit::current_dir)/$(bashunit::current_filename)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert is directory readable when a file is given" \
-      "$a_file" "to be readable" "but is not readable")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert is directory readable when a file is given" \
+    "$a_file" "to be readable" "but is not readable")" \
     "$(assert_is_directory_readable "$a_file")"
 }
 
@@ -123,16 +117,15 @@ function test_unsuccessful_assert_is_directory_readable_without_execution_permis
   local a_directory=$(mktemp -d)
   chmod a-x "$a_directory"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory readable without execution permission" \
-      "$a_directory" "to be readable" "but is not readable")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory readable without execution permission" \
+    "$a_directory" "to be readable" "but is not readable")" \
     "$(assert_is_directory_readable "$a_directory")"
 }
 
 function test_unsuccessful_assert_is_directory_readable_without_read_permission() {
   if [[ "$_BASHUNIT_OS" == "Windows" || $_BASHUNIT_DISTRO = "Alpine" ]]; then
-      return
+    return
   fi
 
   if [[ $EUID -eq 0 ]]; then
@@ -143,16 +136,15 @@ function test_unsuccessful_assert_is_directory_readable_without_read_permission(
   local a_directory=$(mktemp -d)
   chmod a-r "$a_directory"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory readable without read permission" \
-      "$a_directory" "to be readable" "but is not readable")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory readable without read permission" \
+    "$a_directory" "to be readable" "but is not readable")" \
     "$(assert_is_directory_readable "$a_directory")"
 }
 
 function test_successful_assert_is_directory_not_readable_without_read_permission() {
   if [[ "$_BASHUNIT_OS" == "Windows" || $_BASHUNIT_DISTRO = "Alpine" ]]; then
-      return
+    return
   fi
 
   if [[ $EUID -eq 0 ]]; then
@@ -168,7 +160,7 @@ function test_successful_assert_is_directory_not_readable_without_read_permissio
 
 function test_successful_assert_is_directory_not_readable_without_execution_permission() {
   if [[ "$_BASHUNIT_OS" == "Windows" || $_BASHUNIT_DISTRO = "Alpine" ]]; then
-      return
+    return
   fi
 
   if [[ $EUID -eq 0 ]]; then
@@ -185,9 +177,8 @@ function test_successful_assert_is_directory_not_readable_without_execution_perm
 function test_unsuccessful_assert_is_directory_not_readable() {
   local a_directory=$(mktemp -d)
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory not readable" "$a_directory" "to be not readable" "but is readable")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory not readable" "$a_directory" "to be not readable" "but is readable")" \
     "$(assert_is_directory_not_readable "$a_directory")"
 }
 
@@ -199,7 +190,7 @@ function test_successful_assert_is_directory_writable() {
 
 function test_unsuccessful_assert_is_directory_writable() {
   if [[ "$_BASHUNIT_OS" == "Windows" || $_BASHUNIT_DISTRO = "Alpine" ]]; then
-      return
+    return
   fi
 
   if [[ $EUID -eq 0 ]]; then
@@ -210,25 +201,23 @@ function test_unsuccessful_assert_is_directory_writable() {
   local a_directory=$(mktemp -d)
   chmod a-w "$a_directory"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Unsuccessful assert is directory writable" "$a_directory" "to be writable" "but is not writable")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is directory writable" "$a_directory" "to be writable" "but is not writable")" \
     "$(assert_is_directory_writable "$a_directory")"
 }
 
 function test_unsuccessful_assert_is_directory_writable_when_a_file_is_given() {
   local a_file="$(bashunit::current_dir)/$(bashunit::current_filename)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert is directory writable when a file is given" \
-      "$a_file" "to be writable" "but is not writable")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful assert is directory writable when a file is given" \
+    "$a_file" "to be writable" "but is not writable")" \
     "$(assert_is_directory_writable "$a_file")"
 }
 
 function test_successful_assert_is_directory_not_writable() {
   if [[ "$_BASHUNIT_OS" == "Windows" || $_BASHUNIT_DISTRO = "Alpine" ]]; then
-      return
+    return
   fi
 
   if [[ $EUID -eq 0 ]]; then
@@ -245,9 +234,7 @@ function test_successful_assert_is_directory_not_writable() {
 function test_unsuccessful_assert_is_directory_not_writable() {
   local a_directory=$(mktemp -d)
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert is directory not writable" \
-      "$a_directory" "to be not writable" "but is writable")"\
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful assert is directory not writable" \
+    "$a_directory" "to be not writable" "but is writable")" \
     "$(assert_is_directory_not_writable "$a_directory")"
 }
diff --git a/tests/unit/file_test.sh b/tests/unit/file_test.sh
index 4bf17dfd..848b5686 100644
--- a/tests/unit/file_test.sh
+++ b/tests/unit/file_test.sh
@@ -24,9 +24,8 @@ function test_unsuccessful_assert_file_exists() {
 function test_assert_file_exists_should_not_work_with_folders() {
   local a_dir="$(bashunit::current_dir)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-      "Assert file exists should not work with folders" "$a_dir" "to exist but" "do not exist")"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Assert file exists should not work with folders" "$a_dir" "to exist but" "do not exist")" \
     "$(assert_file_exists "$a_dir")"
 }
 
@@ -39,9 +38,9 @@ function test_successful_assert_file_not_exists() {
 function test_unsuccessful_assert_file_not_exists() {
   local a_file="$(bashunit::current_dir)/$(bashunit::current_filename)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert file not exists" "$a_file" "to not exist but" "the file exists")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert file not exists" "$a_file" "to not exist but" "the file exists")" \
     "$(assert_file_not_exists "$a_file")"
 }
 
@@ -63,9 +62,9 @@ function test_unsuccessful_assert_is_file() {
 function test_unsuccessful_assert_is_file_when_a_folder_is_given() {
   local a_folder="$(bashunit::current_dir)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert is file when a folder is given" "$a_folder" "to be a file" "but is not a file")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is file when a folder is given" "$a_folder" "to be a file" "but is not a file")" \
     "$(assert_is_file "$a_folder")"
 }
 
@@ -81,9 +80,9 @@ function test_successful_assert_is_file_empty() {
 function test_unsuccessful_assert_is_file_empty() {
   local a_file="$(bashunit::current_dir)/$(bashunit::current_filename)"
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test\
-      "Unsuccessful assert is file empty" "$a_file" "to be empty" "but is not empty")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful assert is file empty" "$a_file" "to be empty" "but is not empty")" \
     "$(assert_is_file_empty "$a_file")"
 }
 
@@ -97,8 +96,8 @@ function test_successful_assert_files_equals() {
 
   another extra line"
 
-  echo "$file_content" > "$expected"
-  echo "$file_content" > "$actual"
+  echo "$file_content" >"$expected"
+  echo "$file_content" >"$actual"
 
   assert_empty "$(assert_files_equals "$expected" "$actual")"
 
@@ -111,8 +110,8 @@ function test_fails_assert_files_equals() {
   local expected="/tmp/test_fails_assert_files_equals_1"
   local actual="/tmp/test_fails_assert_files_equals_2"
 
-  echo -e "same\noriginal content" > "$expected"
-  echo -e "same\ndifferent content" > "$actual"
+  echo -e "same\noriginal content" >"$expected"
+  echo -e "same\ndifferent content" >"$actual"
 
   assert_contains "Fails assert files equals" \
     "$(assert_files_equals "$expected" "$actual")"
@@ -126,8 +125,8 @@ function test_successful_assert_files_not_equals() {
   local expected="/tmp/test_successful_assert_files_not_equals_1"
   local actual="/tmp/test_successful_assert_files_not_equals_2"
 
-  echo -e "same\noriginal content" > "$expected"
-  echo -e "same\ndifferent content" > "$actual"
+  echo -e "same\noriginal content" >"$expected"
+  echo -e "same\ndifferent content" >"$actual"
 
   assert_empty "$(assert_files_not_equals "$expected" "$actual")"
 
@@ -140,8 +139,8 @@ function test_fails_assert_files_not_equals() {
   local expected="/tmp/test_fails_assert_files_not_equals_1"
   local actual="/tmp/test_fails_assert_files_not_equals_2"
 
-  echo "same content" > "$expected"
-  echo "same content" > "$actual"
+  echo "same content" >"$expected"
+  echo "same content" >"$actual"
 
   assert_contains "Files are equals" \
     "$(assert_files_not_equals "$expected" "$actual")"
@@ -152,7 +151,7 @@ function test_fails_assert_files_not_equals() {
 
 function test_successful_assert_file_contains() {
   local file="/tmp/test_successful_assert_file_contains"
-  echo -e "original content" > "$file"
+  echo -e "original content" >"$file"
 
   assert_successful_code "$(assert_file_contains "$file" "original content")"
 
@@ -161,11 +160,11 @@ function test_successful_assert_file_contains() {
 
 function test_fails_assert_file_contains() {
   local file="/tmp/test_fail_assert_file_contains"
-  echo -e "original content" > "$file"
+  echo -e "original content" >"$file"
 
   assert_contains \
-    "$(bashunit::console_results::print_failed_test\
-      "Fails assert file contains" "${file}" "to contain" "non-existing-str")" \
+    "$(bashunit::console_results::print_failed_test "Fails assert file contains" \
+    "${file}" "to contain" "non-existing-str")" \
     "$(assert_file_contains "$file" "non-existing-str")"
 
   rm "$file"
@@ -173,7 +172,7 @@ function test_fails_assert_file_contains() {
 
 function test_successful_assert_file_not_contains() {
   local file="/tmp/test_successful_assert_file_not_contains"
-  echo -e "original content" > "$file"
+  echo -e "original content" >"$file"
 
   assert_successful_code "$(assert_file_not_contains "$file" "non-existing-str")"
 
@@ -182,11 +181,11 @@ function test_successful_assert_file_not_contains() {
 
 function test_fails_assert_file_not_contains() {
   local file="/tmp/test_fails_assert_file_not_contains"
-  echo -e "original content" > "$file"
+  echo -e "original content" >"$file"
 
   assert_contains \
-    "$(bashunit::console_results::print_failed_test\
-      "Fails assert file not contains" "${file}" "to not contain" "original content")" \
+    "$(bashunit::console_results::print_failed_test "Fails assert file not contains" \
+    "${file}" "to not contain" "original content")" \
     "$(assert_file_not_contains "$file" "original content")"
 
   rm "$file"
diff --git a/tests/unit/fixtures/fake_function_to_spy.sh b/tests/unit/fixtures/fake_function_to_spy.sh
index 3a0f31be..2f52f9da 100644
--- a/tests/unit/fixtures/fake_function_to_spy.sh
+++ b/tests/unit/fixtures/fake_function_to_spy.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
 
-function function_to_be_spied_on(){
+function function_to_be_spied_on() {
   echo "this function should be spy and not execute"
 }
diff --git a/tests/unit/globals_test.sh b/tests/unit/globals_test.sh
index 0c2a3200..05e9f1a7 100644
--- a/tests/unit/globals_test.sh
+++ b/tests/unit/globals_test.sh
@@ -45,7 +45,7 @@ function test_globals_current_timestamp() {
 }
 
 function test_globals_is_command_available() {
-  function existing_fn(){
+  function existing_fn() {
     return 0
   }
   assert_successful_code "$(bashunit::is_command_available existing_fn)"
diff --git a/tests/unit/helpers_test.sh b/tests/unit/helpers_test.sh
index fc78fd9a..8f6fdd18 100644
--- a/tests/unit/helpers_test.sh
+++ b/tests/unit/helpers_test.sh
@@ -53,27 +53,31 @@ function test_normalize_test_function_name_uses_current_interpolated_name_from_s
 }
 
 function test_get_functions_to_run_no_filter_should_return_all_functions() {
-  local functions=("prefix_function1" "prefix_function2" "other_function" "prefix_function3")
+  # Bash 3.0 compatible: separate declaration and assignment
+  local functions
+  functions=("prefix_function1" "prefix_function2" "other_function" "prefix_function3")
 
-  assert_same\
-    "prefix_function1 prefix_function2 prefix_function3"\
+  assert_same "prefix_function1 prefix_function2 prefix_function3" \
     "$(bashunit::helper::get_functions_to_run "prefix" "" "${functions[*]}")"
 }
 
 function test_get_functions_to_run_with_filter_should_return_matching_functions() {
-  local functions=("prefix_function1" "prefix_function2" "other_function" "prefix_function3")
+  local functions
+  functions=("prefix_function1" "prefix_function2" "other_function" "prefix_function3")
 
   assert_same "prefix_function1" "$(bashunit::helper::get_functions_to_run "prefix" "function1" "${functions[*]}")"
 }
 
 function test_get_functions_to_run_filter_no_matching_functions_should_return_empty() {
-  local functions=("prefix_function1" "prefix_function2" "other_function" "prefix_function3")
+  local functions
+  functions=("prefix_function1" "prefix_function2" "other_function" "prefix_function3")
 
   assert_same "" "$(bashunit::helper::get_functions_to_run "prefix" "nonexistent" "${functions[*]}")"
 }
 
 function test_get_functions_to_run_fail_when_duplicates() {
-  local functions=("prefix_function1" "prefix_function1")
+  local functions
+  functions=("prefix_function1" "prefix_function1")
 
   assert_general_error "$(bashunit::helper::get_functions_to_run "prefix" "" "${functions[*]}")"
 }
@@ -154,7 +158,8 @@ function test_get_provider_data() {
 }
 
 function fake_provider_data_array() {
-  local data=("one" "two" "three")
+  local data
+  data=("one" "two" "three")
   bashunit::data_set "${data[@]}"
 }
 
@@ -212,8 +217,8 @@ function test_find_files_recursive_given_dir() {
 
   assert_same "tests/unit/fixtures/tests/example1_test.sh
 tests/unit/fixtures/tests/example2_test.sh
-tests/unit/fixtures/tests/example3_test.bash"\
-  "$result"
+tests/unit/fixtures/tests/example3_test.bash" \
+    "$result"
 }
 
 function test_find_files_recursive_given_wildcard() {
@@ -237,7 +242,7 @@ function test_find_files_recursive_given_bash_extension() {
 }
 
 function test_get_latest_tag() {
-  bashunit::mock git<<EOF
+  bashunit::mock git <<EOF
 fc9aac40eb8e5ad4483f08d79eb678a3650dcf78        refs/tags/0.1.0
 a17e6816669ec8d0f18ed8c6d5564df9fc699bf9        refs/tags/0.10.0
 3977be123b0b73cfdf4b4eff46b909f37aa83b3c        refs/tags/0.10.1
@@ -249,7 +254,8 @@ EOF
 }
 
 function test_to_run_with_filter_matching_string_in_function_name() {
-  local functions=("test_my_awesome_function" "test_your_awesome_function" "test_so_lala_function")
+  local functions
+  functions=("test_my_awesome_function" "test_your_awesome_function" "test_so_lala_function")
 
   assert_same "test_your_awesome_function" \
     "$(bashunit::helper::get_functions_to_run "test" "test_your_awesome_function" "${functions[*]}")"
@@ -331,7 +337,7 @@ function test_parse_file_path_filter_plain_path() {
   {
     read -r file_path || true
     read -r filter || true
-  } <<< "$result"
+  } <<<"$result"
 
   assert_same "tests/unit/example_test.sh" "$file_path"
   assert_same "" "$filter"
@@ -345,7 +351,7 @@ function test_parse_file_path_filter_with_double_colon() {
   {
     read -r file_path || true
     read -r filter || true
-  } <<< "$result"
+  } <<<"$result"
 
   assert_same "tests/unit/example_test.sh" "$file_path"
   assert_same "test_my_function" "$filter"
@@ -359,7 +365,7 @@ function test_parse_file_path_filter_with_line_number() {
   {
     read -r file_path || true
     read -r filter || true
-  } <<< "$result"
+  } <<<"$result"
 
   assert_same "tests/unit/example_test.sh" "$file_path"
   assert_same "__line__:42" "$filter"
@@ -373,7 +379,7 @@ function test_parse_file_path_filter_with_colon_in_path() {
   {
     read -r file_path || true
     read -r filter || true
-  } <<< "$result"
+  } <<<"$result"
 
   assert_same "/path/to:weird/example_test.sh" "$file_path"
   assert_same "test_func" "$filter"
diff --git a/tests/unit/parallel_test.sh b/tests/unit/parallel_test.sh
index da20e295..12905a5c 100644
--- a/tests/unit/parallel_test.sh
+++ b/tests/unit/parallel_test.sh
@@ -120,7 +120,7 @@ function _create_result_file() {
   local content="$3"
 
   mkdir -p "$dir"
-  echo "$content" > "$dir/$filename"
+  echo "$content" >"$dir/$filename"
 }
 
 function test_aggregate_handles_no_result_files() {
diff --git a/tests/unit/redirect_error_test.sh b/tests/unit/redirect_error_test.sh
index 29c6e773..8615b9e4 100644
--- a/tests/unit/redirect_error_test.sh
+++ b/tests/unit/redirect_error_test.sh
@@ -28,9 +28,9 @@ function test_redirect_error_without_log() {
 }
 
 function test_echo_does_not_break_test_execution_result() {
-    local exit_code=0
-    _="$(render_into_error_fd_and_exit "...args")" || exit_code=$?
-    assert_same 1 "$exit_code"
+  local exit_code=0
+  _="$(render_into_error_fd_and_exit "...args")" || exit_code=$?
+  assert_same 1 "$exit_code"
 }
 
 function render_into_error_fd_and_exit() {
diff --git a/tests/unit/release_test.sh b/tests/unit/release_test.sh
index 0a9df41b..9e7dab09 100644
--- a/tests/unit/release_test.sh
+++ b/tests/unit/release_test.sh
@@ -1,5 +1,12 @@
 #!/usr/bin/env bash
 
+# release.sh requires Bash 3.1+ (uses += array syntax)
+# Skip this entire test file on Bash 3.0
+if [[ "${BASH_VERSINFO[0]}" -eq 3 ]] && [[ "${BASH_VERSINFO[1]}" -lt 1 ]]; then
+  # shellcheck disable=SC2317
+  return 0 2>/dev/null || exit 0
+fi
+
 RELEASE_SCRIPT_DIR=""
 FIXTURES_DIR=""
 
@@ -139,7 +146,7 @@ function test_get_checksum_returns_checksum_when_file_exists() {
   # Create a temp checksum file
   local temp_dir
   temp_dir=$(mktemp -d)
-  echo "abc123def456  bin/bashunit" > "$temp_dir/checksum"
+  echo "abc123def456  bin/bashunit" >"$temp_dir/checksum"
 
   # Override the function to use temp dir
   local result
@@ -309,7 +316,7 @@ function test_preflight_check_changelog_unreleased_passes_with_content() {
 function test_preflight_check_changelog_unreleased_fails_when_missing() {
   local temp_dir
   temp_dir=$(mktemp -d)
-  echo "# Changelog" > "$temp_dir/CHANGELOG.md"
+  echo "# Changelog" >"$temp_dir/CHANGELOG.md"
 
   local result
   result=$(cd "$temp_dir" && release::preflight::check_changelog_unreleased 2>&1) || true
@@ -330,7 +337,7 @@ function test_backup_init_creates_directory() {
     cd "$temp_dir" || return
     release::backup::init
     [[ -d "$BACKUP_DIR" ]] && echo "exists"
-  ) > /tmp/backup_test_result 2>&1
+  ) >/tmp/backup_test_result 2>&1
 
   assert_contains "exists" "$(cat /tmp/backup_test_result)" || true
   rm -rf "$temp_dir" /tmp/backup_test_result
@@ -344,7 +351,7 @@ function test_backup_save_file_copies_file() {
   local result
   result=$(
     cd "$temp_dir" || return
-    echo "test content" > testfile.txt
+    echo "test content" >testfile.txt
     release::backup::init
     release::backup::save_file "testfile.txt"
     cat "$BACKUP_DIR/testfile.txt"
@@ -361,10 +368,10 @@ function test_rollback_restore_files_restores_backup() {
   local result
   result=$(
     cd "$temp_dir" || return
-    echo "original content" > testfile.txt
+    echo "original content" >testfile.txt
     release::backup::init
     release::backup::save_file "testfile.txt"
-    echo "modified content" > testfile.txt
+    echo "modified content" >testfile.txt
     release::rollback::restore_files 2>/dev/null
     cat testfile.txt
   )
@@ -612,7 +619,7 @@ function test_sandbox_mock_git_push_allows_other_git_commands() {
     git init --quiet
     git config user.email "test@test.com"
     git config user.name "Test"
-    echo "test" > file.txt
+    echo "test" >file.txt
     git add file.txt
 
     release::sandbox::mock_git_push 2>/dev/null
@@ -635,7 +642,7 @@ function test_update_file_pattern_modifies_file() {
   local temp_dir
   temp_dir=$(mktemp -d)
 
-  echo 'VERSION="1.0.0"' > "$temp_dir/test.txt"
+  echo 'VERSION="1.0.0"' >"$temp_dir/test.txt"
 
   DRY_RUN=false
   (
@@ -654,7 +661,7 @@ function test_update_file_pattern_logs_dry_run() {
   local temp_dir
   temp_dir=$(mktemp -d)
 
-  echo 'VERSION="1.0.0"' > "$temp_dir/test.txt"
+  echo 'VERSION="1.0.0"' >"$temp_dir/test.txt"
 
   DRY_RUN=true
   local output
@@ -782,7 +789,7 @@ function test_update_checksum_updates_package_json() {
 
   cp "$FIXTURES_DIR/mock_package.json" "$temp_dir/package.json"
   mkdir -p "$temp_dir/bin"
-  echo "newchecksum123  bin/bashunit" > "$temp_dir/bin/checksum"
+  echo "newchecksum123  bin/bashunit" >"$temp_dir/bin/checksum"
 
   DRY_RUN=false
   (
diff --git a/tests/unit/setup_teardown_test.sh b/tests/unit/setup_teardown_test.sh
index 9c9e3e36..8c4365ff 100644
--- a/tests/unit/setup_teardown_test.sh
+++ b/tests/unit/setup_teardown_test.sh
@@ -3,19 +3,19 @@
 TEST_COUNTER=1
 
 function set_up_before_script() {
-  TEST_COUNTER=$(( TEST_COUNTER + 1 ))
+  TEST_COUNTER=$((TEST_COUNTER + 1))
 }
 
 function set_up() {
-  TEST_COUNTER=$(( TEST_COUNTER + 1 ))
+  TEST_COUNTER=$((TEST_COUNTER + 1))
 }
 
 function tear_down() {
-  TEST_COUNTER=$(( TEST_COUNTER - 1 ))
+  TEST_COUNTER=$((TEST_COUNTER - 1))
 }
 
 function tear_down_after_script() {
-  TEST_COUNTER=$(( TEST_COUNTER - 1 ))
+  TEST_COUNTER=$((TEST_COUNTER - 1))
 }
 
 function test_counter_is_incremented_after_setup_before_script_and_setup() {
diff --git a/tests/unit/skip_todo_test.sh b/tests/unit/skip_todo_test.sh
index 9a20fdf1..ebe4d4a5 100644
--- a/tests/unit/skip_todo_test.sh
+++ b/tests/unit/skip_todo_test.sh
@@ -1,20 +1,18 @@
 #!/usr/bin/env bash
 
 function test_skip_output() {
-  assert_same\
-    "$(bashunit::console_results::print_skipped_test "Skip output")"\
+  assert_same "$(bashunit::console_results::print_skipped_test "Skip output")" \
     "$(bashunit::skip)"
 }
 
 function test_skip_output_with_reason() {
-  assert_same\
-    "$(bashunit::console_results::print_skipped_test "Skip output with reason" "Skipped because is skippable")"\
+  assert_same \
+    "$(bashunit::console_results::print_skipped_test "Skip output with reason" "Skipped because is skippable")" \
     "$(bashunit::skip "Skipped because is skippable")"
 }
 
 function test_todo_output() {
-  assert_same\
-    "$(bashunit::console_results::print_incomplete_test "Todo output")"\
+  assert_same "$(bashunit::console_results::print_incomplete_test "Todo output")" \
     "$(bashunit::todo)"
 }
 
diff --git a/tests/unit/state_test.sh b/tests/unit/state_test.sh
index 6e38c337..9dc36d4b 100644
--- a/tests/unit/state_test.sh
+++ b/tests/unit/state_test.sh
@@ -248,8 +248,7 @@ function test_initialize_assertions_count() {
     bashunit::state::export_subshell_context
   )
 
-  assert_same\
-    "##ASSERTIONS_FAILED=0\
+  assert_same "##ASSERTIONS_FAILED=0\
 ##ASSERTIONS_PASSED=0\
 ##ASSERTIONS_SKIPPED=0\
 ##ASSERTIONS_INCOMPLETE=0\
@@ -259,7 +258,7 @@ function test_initialize_assertions_count() {
 ##TEST_HOOK_MESSAGE=\
 ##TEST_TITLE=\
 ##TEST_OUTPUT=\
-##"\
+##" \
     "$export_assertions_count"
 }
 
@@ -280,8 +279,7 @@ function test_export_assertions_count() {
     bashunit::state::export_subshell_context
   )
 
-  assert_same\
-    "##ASSERTIONS_FAILED=5\
+  assert_same "##ASSERTIONS_FAILED=5\
 ##ASSERTIONS_PASSED=10\
 ##ASSERTIONS_SKIPPED=42\
 ##ASSERTIONS_INCOMPLETE=12\
@@ -290,7 +288,7 @@ function test_export_assertions_count() {
 ##TEST_HOOK_FAILURE=\
 ##TEST_HOOK_MESSAGE=\
 ##TEST_TITLE=\
-##TEST_OUTPUT=$(echo -n "something" | base64)##"\
+##TEST_OUTPUT=$(echo -n "something" | base64)##" \
     "$export_assertions_count"
 }
 
diff --git a/tests/unit/test_doubles_test.sh b/tests/unit/test_doubles_test.sh
index f759d858..6db2a795 100644
--- a/tests/unit/test_doubles_test.sh
+++ b/tests/unit/test_doubles_test.sh
@@ -15,7 +15,7 @@ function set_up() {
 }
 
 function test_successful_mock() {
-  bashunit::mock ps<<EOF
+  bashunit::mock ps <<EOF
 PID TTY          TIME CMD
 13525 pts/7    00:00:01 bash
 24162 pts/7    00:00:00 ps
@@ -41,8 +41,8 @@ function test_successful_spy() {
 function test_unsuccessful_spy_called() {
   bashunit::spy ps
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful spy called" "ps" "to have been called" "once")"\
+  assert_same \
+    "$(bashunit::console_results::print_failed_test "Unsuccessful spy called" "ps" "to have been called" "once")" \
     "$(assert_have_been_called ps)"
 }
 
@@ -55,28 +55,26 @@ function test_successful_spy_called_times() {
   assert_have_been_called_times 2 ps
 }
 
-
 function test_unsuccessful_spy_called_times() {
   bashunit::spy ps
 
   ps
   ps
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test "Unsuccessful spy called times" "ps" \
+  assert_same "$(bashunit::console_results::print_failed_test "Unsuccessful spy called times" "ps" \
     "to have been called" "1 times" \
-    "actual" "2 times")"\
+    "actual" "2 times")" \
     "$(assert_have_been_called_times 1 ps)"
 }
 
 function test_successful_spy_with_source_function() {
-    # shellcheck source=/dev/null
-    source "$(bashunit::current_dir)/fixtures/fake_function_to_spy.sh"
-    bashunit::spy function_to_be_spied_on
+  # shellcheck source=/dev/null
+  source "$(bashunit::current_dir)/fixtures/fake_function_to_spy.sh"
+  bashunit::spy function_to_be_spied_on
 
-    function_to_be_spied_on
+  function_to_be_spied_on
 
-    assert_have_been_called function_to_be_spied_on
+  assert_have_been_called function_to_be_spied_on
 }
 
 function test_unsuccessful_spy_with_source_function_have_been_called() {
@@ -87,16 +85,14 @@ function test_unsuccessful_spy_with_source_function_have_been_called() {
   function_to_be_spied_on
   function_to_be_spied_on
 
-  assert_same\
-    "$(bashunit::console_results::print_failed_test \
-    "Unsuccessful spy with source function have been called"\
+  assert_same "$(bashunit::console_results::print_failed_test \
+    "Unsuccessful spy with source function have been called" \
     "function_to_be_spied_on" \
     "to have been called" "1 times" \
-    "actual" "2 times")"\
+    "actual" "2 times")" \
     "$(assert_have_been_called_times 1 function_to_be_spied_on)"
 }
 
-
 function test_successful_spy_called_times_with_source() {
   # shellcheck source=/dev/null
   source "$(bashunit::current_dir)/fixtures/fake_function_to_spy.sh"