Test Design Techniques: Static and Code Analysis 🔍

The Story of the Bug Detective Agency 🕵️

Imagine you run a Bug Detective Agency. Your job? Find problems in buildings before people move in. You have two ways to work:

1. Walk around and look (without touching anything) — this is Static Testing
2. Actually live in the house and use everything — this is Dynamic Testing

Both are super important! Let’s explore how testers become the best bug detectives in the software world.

🏠 Static Testing Overview

What Is Static Testing?

Think of it like reading a recipe before cooking. You don’t turn on the stove yet. You just read and check:

• “Wait, it says add 10 cups of salt. That’s way too much!”
• “Hmm, step 3 comes before step 2. That’s wrong!”

Static testing = Finding bugs WITHOUT running the code.

graph TD
    A["📄 Code Written"] --> B["👀 Review & Inspect"]
    B --> C{Found Bugs?}
    C -->|Yes| D["🔧 Fix Now"]
    C -->|No| E["✅ Ready for Next Step"]
    D --> B

Why Is Static Testing Awesome?

Simple Example

Bad Code (spotted statically):

def divide(a, b):
    return a / b  # What if b is 0?

A reviewer reads this and says: “Hey, what happens if someone passes 0 for b? It will crash!”

Fixed:

def divide(a, b):
    if b == 0:
        return "Cannot divide by zero!"
    return a / b

No code was run. The bug was found just by reading!

🏃 Dynamic Testing

What Is Dynamic Testing?

Now you actually cook the recipe. Turn on the stove. Mix ingredients. Taste the food!

Dynamic testing = Running the code and checking if it works correctly.

graph TD
    A["🚀 Run the Program"] --> B["📥 Give It Input"]
    B --> C["📤 Check Output"]
    C --> D{Correct?}
    D -->|Yes| E["✅ Test Passed"]
    D -->|No| F["🐛 Bug Found!"]

Real-Life Example

You have a login page. Dynamic testing means:

1. Type a username and password
2. Click the login button
3. See what happens

Static vs Dynamic: The Difference

Think of buying a used car:

You need BOTH! Looking finds some problems. Driving finds others.

🔬 Static Code Analysis

What Is Static Code Analysis?

Imagine you have a robot helper that reads your code and says:

• “Hey, you made a spelling mistake in this variable!”
• “This line will never run!”
• “You forgot to close the file!”

Static Code Analysis = Using tools to automatically scan code for problems.

graph TD
    A["📝 Your Code"] --> B["🤖 Analysis Tool"]
    B --> C["📋 Report"]
    C --> D["⚠️ Warnings"]
    C --> E["❌ Errors"]
    C --> F["💡 Suggestions"]

What Do These Tools Find?

Popular Static Analysis Tools

Simple Example

Code with issues:

function greet(name) {
    var unused = 42;
    console.log("Hello " + nme);
    return;
    console.log("Goodbye");
}

Static analyzer output:

Line 2: 'unused' is declared but never used
Line 3: 'nme' is not defined (did you mean 'name'?)
Line 5: Unreachable code after return

You haven’t run the code, but the tool found 3 bugs!

👥 Code Review Techniques

What Is Code Review?

Remember group projects at school? Before submitting, your friend reads your work and says:

• “This sentence doesn’t make sense.”
• “You repeated this paragraph twice.”
• “This answer is wrong!”

Code Review = Team members read each other’s code to find problems and share knowledge.

graph TD
    A["👨‍💻 Developer Writes Code"] --> B["📤 Submits for Review"]
    B --> C["👀 Reviewer Reads Code"]
    C --> D{Approved?}
    D -->|No| E["💬 Comments & Suggestions"]
    E --> F["🔧 Developer Fixes"]
    F --> B
    D -->|Yes| G["✅ Code Merged"]

Types of Code Review

What Reviewers Look For

1. Correctness — Does it work right?
2. Readability — Can others understand it?
3. Efficiency — Is it fast enough?
4. Security — Is it safe from hackers?
5. Standards — Does it follow team rules?

Example Code Review Comment

Original code:

def calc(x, y, z):
    return x + y * z

Reviewer comments:

💬 “What do x, y, and z represent? Please use meaningful names like base, rate, hours. Also, should multiplication happen before addition? Add parentheses to make it clear: base + (rate * hours)”

Improved code:

def calculate_pay(base, rate, hours):
    return base + (rate * hours)

Code Review Checklist Example

• [ ] Does the code do what it’s supposed to?
• [ ] Are variable names clear?
• [ ] Are there any bugs I can spot?
• [ ] Is there duplicate code that could be simplified?
• [ ] Are error cases handled?
• [ ] Is it easy to read and understand?

🧬 Mutation Testing

What Is Mutation Testing?

Here’s a fun story! Imagine you have a guard dog. You want to know: Is this dog actually good at catching burglars?

So you send fake burglars! If the dog catches them, it’s a good dog. If fake burglars sneak past, your dog needs training.

Mutation Testing = Making tiny changes to your code (mutations) to see if your tests catch them.

graph TD
    A["📝 Original Code"] --> B["🧬 Create Mutants"]
    B --> C["👾 Mutant 1"]
    B --> D["👾 Mutant 2"]
    B --> E["👾 Mutant 3"]
    C --> F["🧪 Run Tests"]
    D --> F
    E --> F
    F --> G{Test Failed?}
    G -->|Yes| H["✅ Mutant Killed - Good Test!"]
    G -->|No| I["😱 Mutant Survived - Weak Test!"]

How Mutation Testing Works

Step 1: Start with working code and a test

# Original code
def is_adult(age):
    return age >= 18

# Test
def test_is_adult():
    assert is_adult(20) == True

Step 2: Create mutants (tiny changes)

Step 3: Run tests against each mutant

Problem found! Two mutants survived. Our test isn’t good enough!

Better test:

def test_is_adult():
    assert is_adult(20) == True
    assert is_adult(18) == True  # Boundary!
    assert is_adult(17) == False # Below boundary!

Now all mutants would be killed!

Mutation Score

Mutation Score = (Killed Mutants / Total Mutants) × 100%

Common Mutation Types

🎯 Bringing It All Together

Here’s how all these techniques work together in the real world:

graph TD
    A["👨‍💻 Developer Writes Code"] --> B["🤖 Static Analysis"]
    B --> C["👥 Code Review"]
    C --> D["🧪 Write Tests"]
    D --> E["🏃 Dynamic Testing"]
    E --> F["🧬 Mutation Testing"]
    F --> G{All Good?}
    G -->|Yes| H["🚀 Deploy!"]
    G -->|No| A

Quick Comparison

🌟 Key Takeaways

1. Static Testing is like proofreading — find mistakes without running code
2. Dynamic Testing is like test-driving — run the code and check it works
3. Static Code Analysis uses robots to scan your code automatically
4. Code Review is teamwork — humans checking each other’s work
5. Mutation Testing tests your tests — makes sure your safety net has no holes

Remember: Great testers use ALL these tools! Like a detective using magnifying glass, fingerprint kit, AND asking witnesses. Each technique catches different types of bugs.

You’re now ready to be a Bug Detective! Go find those bugs before users do! 🎉