@sebastienrousseau/dotfiles 0.2.469 → 0.2.481

package/scripts/tests/unit/test_dot_cli.sh

@@ -0,0 +1,217 @@
+#!/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

@@ -0,0 +1,67 @@
+#!/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

@@ -0,0 +1,78 @@
+#!/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

@@ -0,0 +1,163 @@
+#!/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

@@ -0,0 +1,113 @@
+#!/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