@sebastienrousseau/dotfiles 0.2.481 → 0.2.499

package/scripts/tests/unit/test_dot_cli.sh

@@ -1,217 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091,SC2034
-# Unit tests for the dot CLI entry point (executable_dot)
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-source "$SCRIPT_DIR/../framework/mocks.sh"
-
-DOT_CLI="$REPO_ROOT/dot_local/bin/executable_dot"
-
-echo "Testing dot CLI entry point..."
-
-# Test: dot CLI file exists
-test_start "dot_cli_exists"
-assert_file_exists "$DOT_CLI" "executable_dot should exist"
-
-# Test: dot CLI has valid bash syntax
-test_start "dot_cli_syntax"
-assert_exit_code 0 "bash -n '$DOT_CLI'"
-
-# Test: dot CLI has shebang
-test_start "dot_cli_shebang"
-first_line=$(head -n 1 "$DOT_CLI")
-if [[ "$first_line" == "#!/usr/bin/env bash" ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: has proper shebang"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should have #!/usr/bin/env bash shebang"
-fi
-
-# Test: dot CLI uses set -e
-test_start "dot_cli_set_e"
-assert_file_contains "$DOT_CLI" "set -e" "should use set -e for error handling"
-
-# Test: dot --help shows usage
-test_start "dot_cli_help"
-output=$(bash "$DOT_CLI" help 2>&1) || true
-if [[ "$output" == *"Usage:"* ]] && [[ "$output" == *"dot"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: help shows usage"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: help should show usage"
-  echo -e "    Output: ${output:0:200}"
-fi
-
-# Test: dot --version shows version
-test_start "dot_cli_version"
-output=$(bash "$DOT_CLI" --version 2>&1) || true
-if [[ "$output" == *"dot v"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: --version shows version string"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: --version should show version"
-  echo -e "    Output: $output"
-fi
-
-# Test: dot (no args) shows help
-test_start "dot_cli_no_args"
-output=$(bash "$DOT_CLI" 2>&1) || true
-if [[ "$output" == *"Usage:"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: no args shows help"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: no args should show help"
-fi
-
-# Test: dot unknown-command shows error
-test_start "dot_cli_unknown_cmd"
-set +e
-output=$(bash "$DOT_CLI" totally-invalid-command-12345 2>&1)
-ec=$?
-set -e
-if [[ "$output" == *"Unknown command"* ]] && [[ $ec -ne 0 ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: unknown command shows error and exits non-zero"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: unknown command should show error"
-  echo -e "    Exit code: $ec"
-  echo -e "    Output: $output"
-fi
-
-# Test: every subcommand in help has a case handler
-test_start "dot_cli_help_handler_parity"
-# Extract subcommands from help text
-help_output=$(bash "$DOT_CLI" help 2>&1)
-help_cmds=()
-while IFS= read -r line; do
-  # Match lines like "  apply       Description..."
-  if [[ "$line" =~ ^[[:space:]]+([a-z][-a-z0-9]+)[[:space:]] ]]; then
-    help_cmds+=("${BASH_REMATCH[1]}")
-  fi
-done <<<"$help_output"
-
-# Extract case handlers from the script
-case_handlers=()
-while IFS= read -r line; do
-  if [[ "$line" =~ ^[[:space:]]+([-a-z]+)\) ]]; then
-    case_handlers+=("${BASH_REMATCH[1]}")
-  fi
-done < <(grep -E '^\s+[a-z][-a-z]*\)' "$DOT_CLI")
-
-missing_handlers=0
-for cmd in "${help_cmds[@]}"; do
-  found=false
-  for handler in "${case_handlers[@]}"; do
-    if [[ "$cmd" == "$handler" ]]; then
-      found=true
-      break
-    fi
-  done
-  # Some help entries are compound (e.g., "--version" is handled by "--version|-v|version)")
-  # Check if command appears anywhere in the script as a case label or reference
-  if [[ "$found" == false ]]; then
-    if grep -qE "(${cmd}[|)]|\"${cmd}\")" "$DOT_CLI" 2>/dev/null; then
-      found=true
-    fi
-  fi
-  if [[ "$found" == false ]]; then
-    echo "    WARNING: help lists '$cmd' but no case handler found"
-    missing_handlers=$((missing_handlers + 1))
-  fi
-done
-
-if [[ $missing_handlers -eq 0 ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: all help subcommands have handlers"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: $missing_handlers help entries lack case handlers"
-fi
-
-# Test: dot --version contains VERSION string from file
-test_start "dot_cli_version_value"
-output=$(bash "$DOT_CLI" --version 2>&1) || true
-if [[ "$output" == *"0.2.480"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: version matches expected v0.2.480"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: version should contain 0.2.480"
-  echo -e "    Output: $output"
-fi
-
-# Test: dot -v is alias for --version
-test_start "dot_cli_v_flag"
-output=$(bash "$DOT_CLI" -v 2>&1) || true
-if [[ "$output" == *"dot v"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: -v is alias for --version"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: -v should show version"
-fi
-
-# Test: dot -h shows help
-test_start "dot_cli_h_flag"
-output=$(bash "$DOT_CLI" -h 2>&1) || true
-if [[ "$output" == *"Usage:"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: -h shows help"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: -h should show help"
-fi
-
-# Test: dot cd without source dir gives informative error
-test_start "dot_cli_cd_no_source"
-set +e
-output=$(CHEZMOI_SOURCE_DIR="" HOME="/nonexistent" bash "$DOT_CLI" cd 2>&1)
-ec=$?
-set -e
-if [[ $ec -ne 0 ]] && [[ "$output" == *"not found"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: dot cd without source exits non-zero with message"
-else
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: dot cd handled (ec=$ec)"
-fi
-
-# Test: dot add with no args shows usage
-test_start "dot_cli_add_no_args"
-set +e
-output=$(CHEZMOI_SOURCE_DIR="$REPO_ROOT" bash "$DOT_CLI" add 2>&1)
-ec=$?
-set -e
-if [[ "$output" == *"Usage:"* ]] && [[ $ec -ne 0 ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: dot add with no args shows usage"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: dot add with no args should show usage (ec=$ec)"
-fi
-
-# Test: dot new with no args shows usage
-test_start "dot_cli_new_no_args"
-set +e
-output=$(CHEZMOI_SOURCE_DIR="$REPO_ROOT" bash "$DOT_CLI" new 2>&1)
-ec=$?
-set -e
-if [[ "$output" == *"Usage:"* ]] && [[ $ec -ne 0 ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: dot new with no args shows usage"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: dot new with no args should show usage (ec=$ec)"
-fi
-
-echo ""
-echo "dot CLI tests completed."
-print_summary

package/scripts/tests/unit/test_encode64.sh

@@ -1,67 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091
-# Unit tests for encode64/decode64 functions
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-
-# Source the function
-FUNC_FILE="$REPO_ROOT/.chezmoitemplates/functions/encode64.sh"
-if [[ -f "$FUNC_FILE" ]]; then
-  source "$FUNC_FILE"
-else
-  echo "SKIP: encode64.sh not found at $FUNC_FILE"
-  echo "RESULTS:0:0:0"
-  exit 0
-fi
-
-echo "Testing encode64/decode64 functions..."
-
-# Test encode64 exists
-test_start "encode64_function_exists"
-assert_true "type encode64 &>/dev/null" "encode64 function should exist"
-
-# Test decode64 exists
-test_start "decode64_function_exists"
-assert_true "type decode64 &>/dev/null" "decode64 function should exist"
-
-# Test encode simple string
-test_start "encode64_simple_string"
-if type encode64 &>/dev/null; then
-  result=$(echo -n "hello" | encode64 2>/dev/null || echo "aGVsbG8=")
-  assert_equals "aGVsbG8=" "$result" "encode64 should encode 'hello' correctly"
-fi
-
-# Test decode simple string
-test_start "decode64_simple_string"
-if type decode64 &>/dev/null; then
-  result=$(echo "aGVsbG8=" | decode64 2>/dev/null || echo "hello")
-  assert_equals "hello" "$result" "decode64 should decode correctly"
-fi
-
-# Test round-trip encoding
-test_start "encode64_roundtrip"
-if type encode64 &>/dev/null && type decode64 &>/dev/null; then
-  original="test string with spaces"
-  encoded=$(echo -n "$original" | encode64 2>/dev/null)
-  decoded=$(echo "$encoded" | decode64 2>/dev/null)
-  assert_equals "$original" "$decoded" "round-trip should preserve original"
-fi
-
-# Test empty string
-test_start "encode64_empty_string"
-if type encode64 &>/dev/null; then
-  result=$(echo -n "" | encode64 2>/dev/null || echo "")
-  assert_true "[[ -z '$result' || '$result' == '' ]]" "empty string encoding"
-fi
-
-# Test special characters
-test_start "encode64_special_chars"
-if type encode64 &>/dev/null; then
-  original="hello@world#123"
-  encoded=$(echo -n "$original" | encode64 2>/dev/null)
-  assert_not_empty "$encoded" "should encode special characters"
-fi
-
-print_summary

package/scripts/tests/unit/test_environment.sh

@@ -1,78 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091,SC2016
-# Unit tests for .chezmoitemplates/functions/environment.sh
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-
-FUNC_FILE="$REPO_ROOT/.chezmoitemplates/functions/environment.sh"
-
-echo "Testing environment function..."
-
-# Test: environment.sh exists
-test_start "environment_file_exists"
-assert_file_exists "$FUNC_FILE" "environment.sh should exist"
-
-# Test: environment.sh has valid syntax
-test_start "environment_syntax"
-assert_exit_code 0 "bash -n '$FUNC_FILE'"
-
-# Source the function
-if [[ -f "$FUNC_FILE" ]]; then
-  source "$FUNC_FILE"
-fi
-
-# Test: environment returns non-empty result
-test_start "environment_returns_value"
-result=$(environment 2>/dev/null)
-assert_not_empty "$result" "environment should return a value"
-
-# Test: environment returns one of the expected values
-test_start "environment_valid_output"
-result=$(environment 2>/dev/null)
-if [[ "$result" == "mac" || "$result" == "linux" || "$result" == "win" || "$result" == "other" ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: returns valid OS ($result)"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should return mac/linux/win/other"
-  echo -e "    Actual: $result"
-fi
-
-# Test: environment --help shows help
-test_start "environment_help"
-output=$(environment --help 2>&1)
-if [[ "$output" == *"Environment Detector"* ]]; then
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: --help shows help text"
-else
-  ((TESTS_FAILED++)) || true
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: --help should show help text"
-fi
-
-# Test: environment uses case statement (no repeated uname calls)
-test_start "environment_single_uname"
-assert_file_contains "$FUNC_FILE" 'case "$os_name"' "should use case statement for single uname call"
-
-# Test: on macOS, environment returns "mac"
-test_start "environment_macos_detection"
-if [[ "$(uname -s)" == "Darwin" ]]; then
-  result=$(environment 2>/dev/null)
-  assert_equals "mac" "$result" "should return 'mac' on macOS"
-else
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: skipped (not macOS)"
-fi
-
-# Test: on Linux, environment returns "linux"
-test_start "environment_linux_detection"
-if [[ "$(uname -s)" == "Linux" ]]; then
-  result=$(environment 2>/dev/null)
-  assert_equals "linux" "$result" "should return 'linux' on Linux"
-else
-  ((TESTS_PASSED++)) || true
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: skipped (not Linux)"
-fi
-
-print_summary

package/scripts/tests/unit/test_extract.sh

@@ -1,163 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091
-# Unit tests for the extract function
-# Tests archive extraction with various formats and edge cases
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-source "$SCRIPT_DIR/../framework/mocks.sh"
-
-# Source the function being tested
-FUNC_FILE="$REPO_ROOT/.chezmoitemplates/functions/extract.sh"
-if [[ -f "$FUNC_FILE" ]]; then
-  source "$FUNC_FILE"
-else
-  echo "Warning: extract.sh not found at $FUNC_FILE"
-fi
-
-# Test: extract with --help flag shows help
-test_start "extract_help"
-output=$(
-  set +u
-  extract --help 2>&1
-)
-if [[ "$output" == *"Usage:"* && "$output" == *"extract"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: --help shows usage information"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: --help should show usage information"
-fi
-
-# Test: extract with --help returns exit code 0
-test_start "extract_help_exit_code"
-(
-  set +u
-  extract --help >/dev/null 2>&1
-)
-assert_equals "0" "$?" "exit code should be 0 for --help"
-
-# Test: extract with no arguments shows error
-test_start "extract_no_args"
-(
-  set +u
-  extract 2>&1
-)
-exit_code=$?
-assert_equals "1" "$exit_code" "exit code should be 1 for no args"
-
-# Test: extract with no arguments shows error message
-test_start "extract_no_args_message"
-output=$(
-  set +u
-  extract 2>&1
-)
-if [[ "$output" == *"ERROR"* || "$output" == *"argument"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: shows error message for no arguments"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should show error message for no arguments"
-  echo -e "    Output: $output"
-fi
-
-# Test: extract with nonexistent file shows error
-test_start "extract_nonexistent_file"
-output=$(extract "/nonexistent/file.tar.gz" 2>&1)
-exit_code=$?
-assert_equals "1" "$exit_code" "exit code should be 1 for nonexistent file"
-
-# Test: extract with nonexistent file shows appropriate error
-test_start "extract_nonexistent_file_message"
-output=$(extract "/nonexistent/file.tar.gz" 2>&1)
-if [[ "$output" == *"ERROR"* || "$output" == *"not a valid file"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: shows error for nonexistent file"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should show error for nonexistent file"
-  echo -e "    Output: $output"
-fi
-
-# Test: extract with too many arguments shows error
-test_start "extract_too_many_args"
-output=$(extract "file1.tar" "file2.tar" 2>&1)
-exit_code=$?
-assert_equals "1" "$exit_code" "exit code should be 1 for too many arguments"
-
-# Test: extract with actual tar.gz file (if tar is available)
-test_start "extract_tar_gz"
-if command -v tar >/dev/null 2>&1; then
-  # Create a test directory and archive
-  test_dir=$(mock_dir "extract_test")
-  mkdir -p "$test_dir/content"
-  echo "test content" >"$test_dir/content/testfile.txt"
-
-  # Create archive
-  archive_file="$test_dir/test.tar.gz"
-  (cd "$test_dir" && tar czf test.tar.gz content)
-
-  # Remove original content
-  rm -rf "$test_dir/content"
-
-  # Extract
-  extract_output_dir="$test_dir/extract_output"
-  mkdir -p "$extract_output_dir"
-  (cd "$extract_output_dir" && extract "$archive_file" >/dev/null 2>&1)
-
-  # Check if extraction created the content
-  if [[ -f "$extract_output_dir/content/testfile.txt" ]]; then
-    ((TESTS_PASSED++))
-    echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: tar.gz extraction works"
-  else
-    ((TESTS_FAILED++))
-    echo -e "  ${RED}✗${NC} $CURRENT_TEST: tar.gz extraction did not produce expected file"
-  fi
-
-  rm -rf "$test_dir"
-else
-  ((TESTS_PASSED++))
-  echo -e "  ${YELLOW}~${NC} $CURRENT_TEST: skipped (tar not available)"
-fi
-
-# Test: extract recognizes unsupported extension
-test_start "extract_unsupported_extension"
-# Create a file with unsupported extension
-test_file=$(mock_file "test content")
-mv "$test_file" "${test_file}.unsupported"
-output=$(extract "${test_file}.unsupported" 2>&1)
-if [[ "$output" == *"cannot be extracted"* ]] || [[ "$output" == *"ERROR"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: unsupported extension handled"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should report unsupported extension"
-  echo -e "    Output: $output"
-fi
-rm -f "${test_file}.unsupported"
-
-# Test: extract with directory instead of file
-test_start "extract_directory"
-test_dir=$(mock_dir "extract_dir_test")
-output=$(extract "$test_dir" 2>&1)
-exit_code=$?
-# Should fail because directories are not files
-if [[ "$exit_code" -ne 0 ]] || [[ "$output" == *"ERROR"* ]] || [[ "$output" == *"not a valid file"* ]]; then
-  ((TESTS_PASSED++))
-  echo -e "  ${GREEN}✓${NC} $CURRENT_TEST: directory correctly rejected"
-else
-  ((TESTS_FAILED++))
-  echo -e "  ${RED}✗${NC} $CURRENT_TEST: should reject directories"
-fi
-rm -rf "$test_dir"
-
-# Test: extract with empty filename
-test_start "extract_empty_filename"
-output=$(extract "" 2>&1)
-exit_code=$?
-assert_equals "1" "$exit_code" "exit code should be 1 for empty filename"
-
-echo ""
-echo "Extract function tests completed."
-echo "RESULTS:$TESTS_RUN:$TESTS_PASSED:$TESTS_FAILED"

package/scripts/tests/unit/test_framework_edge_cases.sh

@@ -1,113 +0,0 @@
-#!/usr/bin/env bash
-# shellcheck disable=SC1090,SC1091,SC2034
-# Unit tests for the test framework itself (assertions.sh edge cases)
-# Ensures assertion functions handle empty strings, special chars, etc.
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../../.." && pwd)}"
-source "$SCRIPT_DIR/../framework/assertions.sh"
-source "$SCRIPT_DIR/../framework/mocks.sh"
-
-echo "Testing assertion framework edge cases..."
-
-# ============ assert_equals edge cases ============
-
-test_start "assert_equals_empty_strings"
-# Both empty strings should be equal
-assert_equals "" "" "empty strings should be equal"
-
-test_start "assert_equals_special_chars"
-assert_equals "hello\nworld" "hello\nworld" "strings with backslash-n should match"
-
-test_start "assert_equals_spaces"
-assert_equals "hello world" "hello world" "strings with spaces should match"
-
-test_start "assert_equals_tabs"
-assert_equals "hello	world" "hello	world" "strings with tabs should match"
-
-# ============ assert_not_equals edge cases ============
-
-test_start "assert_not_equals_different"
-assert_not_equals "hello" "world" "different strings should not be equal"
-
-test_start "assert_not_equals_empty_vs_nonempty"
-assert_not_equals "" "hello" "empty and non-empty should differ"
-
-# ============ assert_empty / assert_not_empty edge cases ============
-
-test_start "assert_empty_with_empty"
-assert_empty "" "empty string should be empty"
-
-test_start "assert_not_empty_with_value"
-assert_not_empty "hello" "non-empty string should not be empty"
-
-test_start "assert_not_empty_with_space"
-assert_not_empty " " "space should not be empty"
-
-# ============ assert_file_exists / assert_file_not_exists ============
-
-test_start "assert_file_exists_real_file"
-test_file=$(mock_file "test content")
-assert_file_exists "$test_file" "mock file should exist"
-
-test_start "assert_file_not_exists_missing"
-assert_file_not_exists "/nonexistent/file_99999.txt" "nonexistent file should not exist"
-
-# ============ assert_dir_exists / assert_dir_not_exists ============
-
-test_start "assert_dir_exists_real_dir"
-test_dir=$(mock_dir "framework_test")
-assert_dir_exists "$test_dir" "mock directory should exist"
-rm -rf "$test_dir"
-
-test_start "assert_dir_not_exists_missing"
-assert_dir_not_exists "/nonexistent/dir_99999" "nonexistent directory should not exist"
-
-# ============ assert_file_contains edge cases ============
-
-test_start "assert_file_contains_literal_dots"
-test_file=$(mock_file "version=1.2.3")
-assert_file_contains "$test_file" "1.2.3" "should find literal dots (not regex)"
-
-test_start "assert_file_contains_special_chars"
-test_file=$(mock_file 'hello [world] (test)')
-assert_file_contains "$test_file" "[world]" "should find literal brackets"
-
-# ============ assert_exit_code edge cases ============
-
-test_start "assert_exit_code_success"
-assert_exit_code 0 "true"
-
-test_start "assert_exit_code_failure"
-assert_exit_code 1 "false"
-
-# ============ assert_output_contains edge cases ============
-
-test_start "assert_output_contains_simple"
-assert_output_contains "hello" "echo hello world"
-
-test_start "assert_output_contains_stderr"
-assert_output_contains "error" "echo error >&2"
-
-# ============ assert_output_not_contains ============
-
-test_start "assert_output_not_contains_simple"
-assert_output_not_contains "xyz" "echo hello world"
-
-# ============ assert_output_matches ============
-
-test_start "assert_output_matches_regex"
-assert_output_matches "[0-9]+" "echo 'test123'"
-
-# ============ print_summary validation ============
-
-test_start "test_counters_consistent"
-# test_start already incremented TESTS_RUN for this test, so account for it
-# TESTS_RUN should equal TESTS_PASSED + TESTS_FAILED + 1 (current unresolved)
-expected_total=$((TESTS_PASSED + TESTS_FAILED + 1))
-assert_equals "$TESTS_RUN" "$expected_total" "TESTS_RUN should equal PASSED + FAILED + 1 (current)"
-
-echo ""
-echo "Framework edge case tests completed."
-print_summary