#!/bin/bash

# Act
local result=$(function_under_test "$input")

# Assert
if [[ "$result" == "$expected" ]]; then
    pass "Basic feature test"
else
    fail "Basic feature test: expected '$expected', got '$result'"
fi

undefined

undefined

**2. Act** - Execute the code under test
```bash

**3. Assert** - Verify the results
```bash

**Complete Example:**
```bash
test_cache_lookup_single_match() {
    # Arrange - Create cache with single match
    local cache_file="$HOME/.goto_index"
    cat > "$cache_file" << EOF

# Act - Lookup folder
local result=$(__goto_cache_lookup "unix-goto")
local exit_code=$?

# Assert - Should return exact path
local expected="/Users/manu/Git_Repos/unix-goto"
if [[ "$result" == "$expected" && $exit_code -eq 0 ]]; then
    pass "Cache lookup returns single match"
else
    fail "Expected '$expected' with code 0, got '$result' with code $exit_code"
fi

undefined

test_cache_lookup_not_found() {
    # Arrange
    local cache_file="$HOME/.goto_index"
    cat > "$cache_file" << EOF

# Act
local result=$(__goto_cache_lookup "nonexistent")
local exit_code=$?

# Assert
if [[ -z "$result" && $exit_code -eq 1 ]]; then
    pass "Cache lookup not found returns code 1"
else
    fail "Expected empty result with code 1, got '$result' with code $exit_code"
fi

# Act
local result=$(__goto_cache_lookup "project")
local exit_code=$?

# Assert - Should return all matches with code 2
local line_count=$(echo "$result" | wc -l)
if [[ $line_count -eq 2 && $exit_code -eq 2 ]]; then
    pass "Cache lookup returns multiple matches with code 2"
else
    fail "Expected 2 lines with code 2, got $line_count lines with code $exit_code"
fi

**Unit Test Checklist:**
- [ ] Test with valid input
- [ ] Test with invalid input
- [ ] Test with empty input
- [ ] Test with boundary values
- [ ] Test return codes
- [ ] Test output format

test_navigation_with_cache() {
    # Arrange - Setup complete navigation environment
    local cache_file="$HOME/.goto_index"
    local history_file="$HOME/.goto_history"

    cat > "$cache_file" << EOF

# Act - Perform full navigation
local start_dir=$(pwd)
goto unix-goto
local nav_exit_code=$?
local end_dir=$(pwd)

# Assert - Should navigate and track history
local expected_dir="/Users/manu/Git_Repos/unix-goto"
local history_recorded=false

if grep -q "$expected_dir" "$history_file" 2>/dev/null; then
    history_recorded=true
fi

if [[ "$end_dir" == "$expected_dir" && $nav_exit_code -eq 0 && $history_recorded == true ]]; then
    pass "Navigation with cache and history tracking"
else
    fail "Integration test failed: nav=$nav_exit_code, dir=$end_dir, history=$history_recorded"
fi

# Cleanup
cd "$start_dir"

# Act - Create bookmark and navigate
bookmark add testwork /Users/manu/work
local add_code=$?

goto @testwork
local nav_code=$?
local nav_dir=$(pwd)

# Assert
local expected_dir="/Users/manu/work"
if [[ $add_code -eq 0 && $nav_code -eq 0 && "$nav_dir" == "$expected_dir" ]]; then
    pass "Bookmark creation and navigation integration"
else
    fail "Integration failed: add=$add_code, nav=$nav_code, dir=$nav_dir"
fi

**Integration Test Checklist:**
- [ ] Test common user workflows
- [ ] Test module interactions
- [ ] Test data persistence
- [ ] Test state changes
- [ ] Test error propagation
- [ ] Test cleanup behavior

test_empty_cache_file() {
    # Arrange - Create empty cache file
    local cache_file="$HOME/.goto_index"
    touch "$cache_file"

    # Act
    local result=$(__goto_cache_lookup "anything")
    local exit_code=$?

    # Assert - Should handle gracefully
    if [[ -z "$result" && $exit_code -eq 1 ]]; then
        pass "Empty cache file handled gracefully"
    else
        fail "Empty cache should return code 1"
    fi
}

test_malformed_cache_entry() {
    # Arrange - Cache with malformed entry
    local cache_file="$HOME/.goto_index"
    cat > "$cache_file" << EOF

# Act
local result=$(__goto_cache_lookup "valid-entry")
local exit_code=$?

# Assert - Should still find valid entry
if [[ "$result" == "/valid/path" && $exit_code -eq 0 ]]; then
    pass "Malformed entry doesn't break valid lookups"
else
    fail "Should handle malformed entries gracefully"
fi

# Act
local result=$(__goto_cache_lookup "longpath")
local exit_code=$?

# Assert - Should handle long paths
if [[ "$result" == "$long_path" && $exit_code -eq 0 ]]; then
    pass "Very long paths handled correctly"
else
    fail "Long path handling failed"
fi

# Act
local result=$(__goto_cache_lookup "my-project_v2.0")
local exit_code=$?

# Assert
if [[ "$result" == "/Users/manu/my-project_v2.0" && $exit_code -eq 0 ]]; then
    pass "Special characters in folder name"
else
    fail "Special character handling failed"
fi

# Act - Simulate concurrent access
(
    for i in {1..10}; do
        __goto_cache_lookup "unix-goto" &
    done
    wait
)
local exit_code=$?

# Assert - Should handle concurrent reads
if [[ $exit_code -eq 0 ]]; then
    pass "Concurrent cache access handled"
else
    fail "Concurrent access failed"
fi

**Edge Case Test Checklist:**
- [ ] Empty inputs
- [ ] Missing files
- [ ] Malformed data
- [ ] Very large inputs
- [ ] Special characters
- [ ] Concurrent access
- [ ] Resource exhaustion
- [ ] Permission errors

test_cache_lookup_speed() {
    # Arrange - Build cache
    __goto_cache_build

    # Act - Measure lookup time
    local start=$(date +%s%N)
    __goto_cache_lookup "unix-goto"
    local end=$(date +%s%N)

    # Assert - Should be <100ms
    local duration=$(((end - start) / 1000000))
    local target=100

    if [ $duration -lt $target ]; then
        pass "Cache lookup speed: ${duration}ms (target: <${target}ms)"
    else
        fail "Cache too slow: ${duration}ms (target: <${target}ms)"
    fi
}

test_cache_build_performance() {
    # Arrange - Clean cache
    rm -f ~/.goto_index

    # Act - Measure build time
    local start=$(date +%s%N)
    __goto_cache_build
    local end=$(date +%s%N)

    # Assert - Should be <5 seconds
    local duration=$(((end - start) / 1000000))
    local target=5000

    if [ $duration -lt $target ]; then
        pass "Cache build speed: ${duration}ms (target: <${target}ms)"
    else
        fail "Cache build too slow: ${duration}ms (target: <${target}ms)"
    fi
}

test_history_retrieval_speed() {
    # Arrange - Create history with 100 entries
    local history_file="$HOME/.goto_history"
    rm -f "$history_file"
    for i in {1..100}; do
        echo "$(date +%s)|/path/to/dir$i" >> "$history_file"
    done

    # Act - Measure retrieval time
    local start=$(date +%s%N)
    __goto_recent_dirs 10
    local end=$(date +%s%N)

    # Assert - Should be <10ms
    local duration=$(((end - start) / 1000000))
    local target=10

    if [ $duration -lt $target ]; then
        pass "History retrieval: ${duration}ms (target: <${target}ms)"
    else
        fail "History too slow: ${duration}ms (target: <${target}ms)"
    fi
}

test_benchmark_cache_at_scale() {
    # Arrange - Create large workspace
    local workspace=$(mktemp -d)
    for i in {1..500}; do
        mkdir -p "$workspace/folder-$i"
    done

    # Act - Build cache and measure lookup
    local old_paths="$GOTO_SEARCH_PATHS"
    export GOTO_SEARCH_PATHS="$workspace"

    __goto_cache_build

    local start=$(date +%s%N)
    __goto_cache_lookup "folder-250"
    local end=$(date +%s%N)

    # Assert - Even with 500 folders, should be <100ms
    local duration=$(((end - start) / 1000000))
    local target=100

    if [ $duration -lt $target ]; then
        pass "Cache at scale (500 folders): ${duration}ms"
    else
        fail "Cache at scale too slow: ${duration}ms"
    fi

    # Cleanup
    export GOTO_SEARCH_PATHS="$old_paths"
    rm -rf "$workspace"
}

assert_equal() {
    local expected="$1"
    local actual="$2"
    local message="${3:-String equality}"

    if [[ "$actual" == "$expected" ]]; then
        pass "$message"
    else
        fail "$message: expected '$expected', got '$actual'"
    fi
}

**Exit Code Assertions:**
```bash
assert_success() {
    local exit_code=$?
    local message="${1:-Command should succeed}"

    if [ $exit_code -eq 0 ]; then
        pass "$message"
    else
        fail "$message: exit code $exit_code"
    fi
}

assert_failure() {
    local exit_code=$?
    local message="${1:-Command should fail}"

    if [ $exit_code -ne 0 ]; then
        pass "$message"
    else
        fail "$message: expected non-zero exit code"
    fi
}

**Numeric Comparisons:**
```bash
assert_less_than() {
    local actual=$1
    local limit=$2
    local message="${3:-Value should be less than limit}"

    if [ $actual -lt $limit ]; then
        pass "$message: $actual < $limit"
    else
        fail "$message: $actual >= $limit"
    fi
}

assert_greater_than() {
    local actual=$1
    local limit=$2
    local message="${3:-Value should be greater than limit}"

    if [ $actual -gt $limit ]; then
        pass "$message: $actual > $limit"
    else
        fail "$message: $actual <= $limit"
    fi
}

undefined

assert_file_exists() {
    local file="$1"
    local message="${2:-File should exist}"

    if [ -f "$file" ]; then
        pass "$message: $file"
    else
        fail "$message: $file not found"
    fi
}

assert_dir_exists() {
    local dir="$1"
    local message="${2:-Directory should exist}"

    if [ -d "$dir" ]; then
        pass "$message: $dir"
    else
        fail "$message: $dir not found"
    fi
}

**File Content Assertions:**
```bash
assert_file_contains() {
    local file="$1"
    local pattern="$2"
    local message="${3:-File should contain pattern}"

    if grep -q "$pattern" "$file" 2>/dev/null; then
        pass "$message"
    else
        fail "$message: pattern '$pattern' not found in $file"
    fi
}

assert_line_count() {
    local file="$1"
    local expected=$2
    local message="${3:-File should have expected line count}"

    local actual=$(wc -l < "$file" | tr -d ' ')

    if [ $actual -eq $expected ]; then
        pass "$message: $actual lines"
    else
        fail "$message: expected $expected lines, got $actual"
    fi
}

undefined

assert_output_contains() {
    local output="$1"
    local pattern="$2"
    local message="${3:-Output should contain pattern}"

    if [[ "$output" =~ $pattern ]]; then
        pass "$message"
    else
        fail "$message: pattern '$pattern' not found in output"
    fi
}

**Empty Output:**
```bash
assert_output_empty() {
    local output="$1"
    local message="${2:-Output should be empty}"

    if [[ -z "$output" ]]; then
        pass "$message"
    else
        fail "$message: got '$output'"
    fi
}

undefined

#!/bin/bash

# Backup real files
[ -f "$HOME/.goto_index" ] && cp "$HOME/.goto_index" "$TEST_TEMP_DIR/goto_index.bak"
[ -f "$HOME/.goto_bookmarks" ] && cp "$HOME/.goto_bookmarks" "$TEST_TEMP_DIR/goto_bookmarks.bak"
[ -f "$HOME/.goto_history" ] && cp "$HOME/.goto_history" "$TEST_TEMP_DIR/goto_history.bak"

# Remove temp directory
rm -rf "$TEST_TEMP_DIR"

cat > "$cache_file" << EOF

for i in $(seq 1 $entries); do
    echo "folder-$i|/path/to/folder-$i|2|$(date +%s)" >> "$cache_file"
done

rm -f "$bookmark_file"
for i in $(seq 1 $count); do
    echo "bookmark$i|/path/to/bookmark$i|$(date +%s)" >> "$bookmark_file"
done

rm -f "$history_file"
for i in $(seq 1 $count); do
    echo "$(date +%s)|/path/to/dir$i" >> "$history_file"
done

local start=$(date +%s%N)
$func $args
local end=$(date +%s%N)

echo $(((end - start) / 1000000))

if declare -f "$func" > /dev/null; then
    pass "Function $func exists"
else
    fail "Function $func not found"
fi

if [ -n "${!var}" ]; then
    pass "Variable $var is set"
else
    fail "Variable $var not set"
fi

undefined

#!/bin/bash

# Arrange
cat > "$HOME/.goto_index" << EOF

# Act
local result=$(__goto_cache_lookup "unix-goto")
local exit_code=$?

# Assert
if [[ "$result" == "/Users/manu/Git_Repos/unix-goto" && $exit_code -eq 0 ]]; then
    pass "Unit: Single match lookup"
else
    fail "Unit: Single match lookup - got '$result' code $exit_code"
fi

teardown_test_env

# Arrange
create_test_cache 5

# Act
local result=$(__goto_cache_lookup "nonexistent")
local exit_code=$?

# Assert
if [[ -z "$result" && $exit_code -eq 1 ]]; then
    pass "Unit: Not found returns code 1"
else
    fail "Unit: Not found - got '$result' code $exit_code"
fi

teardown_test_env

# Arrange
cat > "$HOME/.goto_index" << EOF

# Act
local result=$(__goto_cache_lookup "project")
local exit_code=$?
local line_count=$(echo "$result" | wc -l | tr -d ' ')

# Assert
if [[ $line_count -eq 2 && $exit_code -eq 2 ]]; then
    pass "Unit: Multiple matches returns code 2"
else
    fail "Unit: Multiple matches - got $line_count lines code $exit_code"
fi

teardown_test_env

# Arrange
rm -f "$HOME/.goto_index"

# Act
__goto_cache_build
local build_code=$?

local result=$(__goto_cache_lookup "unix-goto")
local lookup_code=$?

# Assert
if [[ $build_code -eq 0 && $lookup_code -eq 0 && -n "$result" ]]; then
    pass "Integration: Build and lookup"
else
    fail "Integration: Build ($build_code) and lookup ($lookup_code) failed"
fi

teardown_test_env

# Arrange
touch "$HOME/.goto_index"

# Act
local result=$(__goto_cache_lookup "anything")
local exit_code=$?

# Assert
if [[ -z "$result" && $exit_code -eq 1 ]]; then
    pass "Edge: Empty cache handled"
else
    fail "Edge: Empty cache should return code 1"
fi

teardown_test_env

# Arrange
cat > "$HOME/.goto_index" << EOF

# Act
local result=$(__goto_cache_lookup "my-project_v2.0")
local exit_code=$?

# Assert
if [[ "$result" == "/Users/manu/my-project_v2.0" && $exit_code -eq 0 ]]; then
    pass "Edge: Special characters in name"
else
    fail "Edge: Special characters failed"
fi

teardown_test_env

# Arrange
create_test_cache 100

# Act
local duration=$(time_function_ms __goto_cache_lookup "folder-50")

# Assert - Should be <100ms
if [ $duration -lt 100 ]; then
    pass "Performance: Cache lookup ${duration}ms (<100ms target)"
else
    fail "Performance: Cache too slow ${duration}ms"
fi

teardown_test_env

# Arrange
rm -f "$HOME/.goto_index"

# Act
local duration=$(time_function_ms __goto_cache_build)

# Assert - Should be <5000ms (5 seconds)
if [ $duration -lt 5000 ]; then
    pass "Performance: Cache build ${duration}ms (<5000ms target)"
else
    fail "Performance: Cache build too slow ${duration}ms"
fi

teardown_test_env

undefined

#!/bin/bash

# Act
local duration=$(bench_time_ms $cmd)

# Assert - Should be ~100ms
if [ $duration -ge 90 ] && [ $duration -le 150 ]; then
    pass "bench_time_ms measures correctly: ${duration}ms"
else
    fail "bench_time_ms inaccurate: ${duration}ms (expected ~100ms)"
fi

# Act
local stats=$(bench_calculate_stats "${values[@]}")
IFS=',' read -r min max mean median stddev <<< "$stats"

# Assert
if [[ $min -eq 10 && $max -eq 50 && $mean -eq 30 ]]; then
    pass "bench_calculate_stats computes correctly"
else
    fail "Stats calculation failed: min=$min max=$max mean=$mean"
fi

# Assert
if [ -d "$workspace" ] && [ $(ls -1 "$workspace" | wc -l) -eq 10 ]; then
    pass "Workspace creation (small: 10 folders)"
    bench_cleanup_workspace "$workspace"
else
    fail "Workspace creation failed"
fi

undefined

test-cache.sh          # Test cache system
test-bookmark.sh       # Test bookmarks
test-navigation.sh     # Test navigation
test-benchmark.sh      # Test benchmarks

test_[category]_[feature]_[scenario]

Examples:
test_unit_cache_lookup_single_match
test_integration_navigation_with_cache
test_edge_empty_input
test_performance_cache_speed

undefined

# Test
result=$(function_under_test)

# Cleanup own resources
rm -f "$temp"

# Assert
[[ "$result" == "expected" ]] && pass "Test" || fail "Test"

undefined

undefined

undefined

undefined

---

**Skill Version:** 1.0
**Last Updated:** October 2025
**Maintained By:** Manu Tej + Claude Code
**Source:** unix-goto testing patterns and methodologies