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! 🎉