Git - Bisect & Debugging

# Binary search visualization
Commits: A---B---C---D---E---F---G---H (bug here)
         ✓   ✓   ✓   ✓   ✗   ✗   ✗   ✗

Step 1: Test middle (E) → Bad
Step 2: Test middle of A-D (C) → Good  
Step 3: Test middle of C-E (D) → Good
Step 4: E is the first bad commit!

# Start bisecting
git bisect start

# Mark current commit as bad (has the bug)
git bisect bad

# Mark a known good commit (before bug was introduced)
git bisect good v1.2.0    # or specific commit hash

# Git checks out a commit in the middle
# Test the commit, then mark it:
git bisect good    # if no bug
git bisect bad     # if bug exists

# Repeat until Git finds the first bad commit
# Git will show: "abc1234 is the first bad commit"

# End bisecting session
git bisect reset

# Start bisect with good and bad commits
git bisect start HEAD v1.2.0
git bisect start <bad-commit> <good-commit>

# Start with specific range
git bisect start main feature/user-auth

# Create test script (test.sh)
#!/bin/bash
# Exit 0 for good, 1 for bad, 125 for skip

make clean && make
if [ $? -ne 0 ]; then
    exit 125  # Skip if can't build
fi

# Run specific test
./run_test user_login_test
exit $?

# Run automated bisect
git bisect start HEAD v1.0
git bisect run ./test.sh

# Git will automatically find the first bad commit

# Node.js test script
#!/bin/bash
npm install --silent
npm test -- --testNamePattern="user authentication"
exit $?

# Python test script  
#!/bin/bash
python -m pytest tests/test_authentication.py::test_login
exit $?

# Java test script
#!/bin/bash
mvn test -Dtest=UserAuthenticationTest -q
exit $?

# Mark multiple good commits
git bisect good commit1 commit2 commit3

# Mark multiple bad commits  
git bisect bad commit4 commit5

# Show current bisect status
git bisect log

# Skip commit that can't be tested (e.g., doesn't compile)
git bisect skip

# Skip specific commits  
git bisect skip commit1 commit2

# Skip range of commits
git bisect skip commit1..commit2

# Only consider commits that changed specific files
git bisect start HEAD v1.0 -- src/auth/

# Bisect only commits affecting certain paths
git bisect start HEAD v1.0 -- "*.js" "*.ts"

#!/bin/bash
# performance-test.sh - Find performance regression

# Build application
make clean && make
if [ $? -ne 0 ]; then
    exit 125  # Skip if build fails
fi

# Run performance test
start_time=$(date +%s.%N)
./run_benchmark
end_time=$(date +%s.%N)

# Calculate runtime
runtime=$(echo "$end_time - $start_time" | bc)

# Check if runtime exceeds threshold (e.g., 5 seconds)
if (( $(echo "$runtime > 5.0" | bc -l) )); then
    exit 1  # Bad (too slow)
else
    exit 0  # Good (fast enough)
fi

#!/bin/bash
# flaky-test.sh - Find intermittent bug

# Run test multiple times
for i in {1..10}; do
    echo "Test run $i"
    npm test -- --testNamePattern="flaky test"
    if [ $? -ne 0 ]; then
        exit 1  # Found the bug
    fi
done

exit 0  # No bug detected

#!/bin/bash
# memory-test.sh - Detect memory leaks

# Start application with memory monitoring
valgrind --leak-check=full --error-exitcode=1 ./app &
APP_PID=$!

# Run load test
curl -f http://localhost:8080/stress-test

# Check if app is still running (no crash)
if kill -0 $APP_PID 2>/dev/null; then
    kill $APP_PID
    wait $APP_PID
    exit $?
else
    exit 1  # App crashed
fi

# Show bisect log with visualization
git bisect log | git log --graph --oneline --stdin

# Visualize current bisect state
git log --graph --oneline --bisect --all

# Show commits being tested
git rev-list --bisect-all HEAD...v1.0

# After finding the bad commit
git show <bad-commit>
git log -p <bad-commit>^..<bad-commit>

# Show files changed in bad commit
git diff-tree --no-commit-id --name-only -r <bad-commit>

# Show commit context
git log --oneline -5 <bad-commit>

# Bisect between different branches
git bisect start feature/broken main

# Bisect within merge commits
git bisect start --first-parent HEAD v1.0

# Update submodules during bisect
git bisect start
git bisect bad
git bisect good v1.0

# In bisect test script
#!/bin/bash
git submodule update --init --recursive
make test
exit $?

# CI bisect script
#!/bin/bash
# ci-bisect.sh

if [ "$1" = "good" ] && [ "$2" = "bad" ]; then
    git bisect start $2 $1
    git bisect run .ci/test-script.sh
    
    # Report results
    git bisect log > bisect-results.txt
    git bisect reset
fi

# Handle build failures in test script
#!/bin/bash
# robust-test.sh

# Try to build
make clean && make
if [ $? -ne 0 ]; then
    echo "Build failed, skipping..."
    exit 125  # Tell git bisect to skip
fi

# Run actual test
./run_test
exit $?

# More robust test with retries
#!/bin/bash
# retry-test.sh

ATTEMPTS=3
for i in $(seq 1 $ATTEMPTS); do
    echo "Attempt $i of $ATTEMPTS"
    ./run_test
    RESULT=$?
    
    if [ $RESULT -eq 0 ]; then
        exit 0  # Success
    fi
    
    if [ $i -lt $ATTEMPTS ]; then
        echo "Test failed, retrying..."
        sleep 1
    fi
done

exit 1  # All attempts failed

# Reset bisect if something goes wrong
git bisect reset

# Start over with more specific range
git bisect start --term-new=broken --term-old=working

# Check bisect status
git bisect log
git status

# VS Code bisect task (.vscode/tasks.json)
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Git Bisect Run",
            "type": "shell",
            "command": "git",
            "args": ["bisect", "run", "./test.sh"],
            "group": "test"
        }
    ]
}

# GitKraken, SourceTree, Git Extensions
# Most GUI tools support bisect visually

# Command line with GUI diff
git config --global merge.tool vimdiff
git bisect start
git bisect bad
git bisect good v1.0
# At each step, use: git difftool HEAD~1 HEAD

# Fast, focused test
#!/bin/bash
# optimal-test.sh

# Quick compile check
if ! make -j$(nproc) --quiet; then
    exit 125
fi

# Run only the failing test, not entire suite
python -m pytest tests/specific_failing_test.py -v --tb=no -q
exit $?

# Document bisect session
git bisect log > bisect-session-$(date +%Y%m%d).log

# Create bug report with bisect info
echo "Bug introduced in commit: $(git bisect bad)" > bug-report.md
echo "Files changed:" >> bug-report.md
git diff-tree --no-commit-id --name-only -r $(git bisect bad) >> bug-report.md

# After finding bad commit, find specific line
BAD_COMMIT=$(git rev-parse --short HEAD)
git bisect reset

# Find who changed the problematic line
git blame $BAD_COMMIT -- problematic_file.js

# Show evolution of specific function
git log -p -S "function_name" -- file.js

# Test for multiple bugs simultaneously
#!/bin/bash
# multi-bug-test.sh

# Test bug A
./test_bug_a.sh
BUG_A=$?

# Test bug B  
./test_bug_b.sh
BUG_B=$?

# Both bugs must be present to mark as bad
if [ $BUG_A -ne 0 ] && [ $BUG_B -ne 0 ]; then
    exit 1  # Both bugs present
else
    exit 0  # At least one bug fixed
fi

# Use parallel builds
make -j$(nproc)

# Cache dependencies
if [ ! -d "node_modules" ]; then
    npm ci --silent
fi

# Skip expensive operations
export NODE_ENV=test
export SKIP_INTEGRATION_TESTS=true

# Only bisect commits that touch relevant files
git bisect start HEAD v1.0 -- src/authentication/

# Skip merge commits
git bisect start --first-parent HEAD v1.0

# Bisect specific author's commits
git log --author="John Doe" --format="%H" v1.0..HEAD | git bisect start --stdin