Back to Course|6 hours|Beginner

Manual Testing Techniques

Master manual testing techniques and test case design methodologies.

Progress: 0/5 topics completed0%

Select Topics Overview

Test Case Design & Writing

Learn how to write effective test cases that cover all scenarios and requirements

Content by: Paras Dadhania

Software Testing & QA Specialist

Connect

Test Case Components

•Test Case ID: Unique identifier
•Test Description: What is being tested
•Preconditions: Setup requirements
•Test Steps: Detailed execution steps
•Expected Result: What should happen
•Actual Result: What actually happened
•Status: Pass/Fail/Blocked

Test Case Template

Code Example

Test Case ID: TC_LOGIN_001
Test Description: Verify user can login with valid credentials
Preconditions: 
- User account exists in system
- User is on login page
- Database is accessible

Test Steps:
1. Enter valid username "testuser"
2. Enter valid password "testpass123"
3. Click "Login" button
4. Wait for page to load

Expected Result: 
- User should be redirected to dashboard
- Welcome message should display
- User menu should be visible

Actual Result: [To be filled during execution]
Status: [Pass/Fail/Blocked]

Swipe to see more code

Test Case ID: TC_LOGIN_001
Test Description: Verify user can login with valid credentials
Preconditions: 
- User account exists in system
- User is on login page
- Database is accessible

Test Steps:
1. Enter valid username "testuser"
2. Enter valid password "testpass123"
3. Click "Login" button
4. Wait for page to load

Expected Result: 
- User should be redirected to dashboard
- Welcome message should display
- User menu should be visible

Actual Result: [To be filled during execution]
Status: [Pass/Fail/Blocked]

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Black Box Testing Techniques

Learn black box testing techniques that focus on functionality without knowing internal code

Content by: Yash Sanghavi

Software Testing & QA Specialist

Connect

Black Box Testing Principles

•Tests functionality without knowing internal structure
•Focuses on inputs and outputs
•Tests from user perspective
•Validates requirements and specifications
•Independent of implementation details

Black Box Testing Techniques

Code Example

// Equivalence Partitioning
// Divide input data into valid and invalid groups
function testAgeValidation() {
    // Valid partitions: 18-65
    // Invalid partitions: <18, >65, non-numeric
    
    // Valid test cases
    testValidAge(25); // Should pass
    testValidAge(18); // Should pass
    testValidAge(65); // Should pass
    
    // Invalid test cases
    testInvalidAge(17); // Should fail
    testInvalidAge(66); // Should fail
    testInvalidAge("abc"); // Should fail
}

// Boundary Value Analysis
// Test values at boundaries of input ranges
function testBoundaryValues() {
    // For age range 18-65
    // Test boundaries: 17, 18, 19, 64, 65, 66
    
    testBoundary(17); // Just below minimum
    testBoundary(18); // Minimum valid
    testBoundary(19); // Just above minimum
    testBoundary(64); // Just below maximum
    testBoundary(65); // Maximum valid
    testBoundary(66); // Just above maximum
}

// Decision Table Testing
// Test different combinations of conditions
function testLoginDecisionTable() {
    // Conditions: Valid username, Valid password, Account active
    // Rules: All combinations of true/false
    
    // Rule 1: All true -> Login successful
    testLogin(true, true, true); // Should pass
    
    // Rule 2: Invalid username -> Login failed
    testLogin(false, true, true); // Should fail
    
    // Rule 3: Invalid password -> Login failed
    testLogin(true, false, true); // Should fail
    
    // Rule 4: Account inactive -> Login failed
    testLogin(true, true, false); // Should fail
}

Swipe to see more code

// Equivalence Partitioning
// Divide input data into valid and invalid groups
function testAgeValidation() {
    // Valid partitions: 18-65
    // Invalid partitions: <18, >65, non-numeric
    
    // Valid test cases
    testValidAge(25); // Should pass
    testValidAge(18); // Should pass
    testValidAge(65); // Should pass
    
    // Invalid test cases
    testInvalidAge(17); // Should fail
    testInvalidAge(66); // Should fail
    testInvalidAge("abc"); // Should fail
}

// Boundary Value Analysis
// Test values at boundaries of input ranges
function testBoundaryValues() {
    // For age range 18-65
    // Test boundaries: 17, 18, 19, 64, 65, 66
    
    testBoundary(17); // Just below minimum
    testBoundary(18); // Minimum valid
    testBoundary(19); // Just above minimum
    testBoundary(64); // Just below maximum
    testBoundary(65); // Maximum valid
    testBoundary(66); // Just above maximum
}

// Decision Table Testing
// Test different combinations of conditions
function testLoginDecisionTable() {
    // Conditions: Valid username, Valid password, Account active
    // Rules: All combinations of true/false
    
    // Rule 1: All true -> Login successful
    testLogin(true, true, true); // Should pass
    
    // Rule 2: Invalid username -> Login failed
    testLogin(false, true, true); // Should fail
    
    // Rule 3: Invalid password -> Login failed
    testLogin(true, false, true); // Should fail
    
    // Rule 4: Account inactive -> Login failed
    testLogin(true, true, false); // Should fail
}

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

White Box Testing Techniques

Learn white box testing techniques that examine internal code structure and logic

Content by: Paras Dadhania

Software Testing & QA Specialist

Connect

White Box Testing Principles

•Tests internal code structure and logic
•Requires knowledge of source code
•Focuses on code coverage
•Tests all code paths and branches
•Validates internal logic and algorithms

Code Coverage Types

Code Example

// Statement Coverage
// Every line of code is executed at least once
function calculateGrade(score) {
    if (score >= 90) {        // Line 1
        return 'A';           // Line 2
    } else if (score >= 80) { // Line 3
        return 'B';           // Line 4
    } else if (score >= 70) { // Line 5
        return 'C';           // Line 6
    } else {                  // Line 7
        return 'F';           // Line 8
    }
}

// Test cases for 100% statement coverage
test('score 95 should return A', () => {
    expect(calculateGrade(95)).toBe('A'); // Covers lines 1, 2
});

test('score 85 should return B', () => {
    expect(calculateGrade(85)).toBe('B'); // Covers lines 1, 3, 4
});

test('score 75 should return C', () => {
    expect(calculateGrade(75)).toBe('C'); // Covers lines 1, 3, 5, 6
});

test('score 65 should return F', () => {
    expect(calculateGrade(65)).toBe('F'); // Covers lines 1, 3, 5, 7, 8
});

// Branch Coverage
// Every decision point is tested for both true and false
function validateUser(user) {
    if (user.age >= 18) {           // Branch 1: true/false
        if (user.email) {           // Branch 2: true/false
            return true;
        }
    }
    return false;
}

// Test all branch combinations
test('valid adult with email', () => {
    const user = { age: 25, email: 'test@example.com' };
    expect(validateUser(user)).toBe(true); // Branch 1: true, Branch 2: true
});

test('valid adult without email', () => {
    const user = { age: 25, email: null };
    expect(validateUser(user)).toBe(false); // Branch 1: true, Branch 2: false
});

test('minor with email', () => {
    const user = { age: 17, email: 'test@example.com' };
    expect(validateUser(user)).toBe(false); // Branch 1: false
});

Swipe to see more code

// Statement Coverage
// Every line of code is executed at least once
function calculateGrade(score) {
    if (score >= 90) {        // Line 1
        return 'A';           // Line 2
    } else if (score >= 80) { // Line 3
        return 'B';           // Line 4
    } else if (score >= 70) { // Line 5
        return 'C';           // Line 6
    } else {                  // Line 7
        return 'F';           // Line 8
    }
}

// Test cases for 100% statement coverage
test('score 95 should return A', () => {
    expect(calculateGrade(95)).toBe('A'); // Covers lines 1, 2
});

test('score 85 should return B', () => {
    expect(calculateGrade(85)).toBe('B'); // Covers lines 1, 3, 4
});

test('score 75 should return C', () => {
    expect(calculateGrade(75)).toBe('C'); // Covers lines 1, 3, 5, 6
});

test('score 65 should return F', () => {
    expect(calculateGrade(65)).toBe('F'); // Covers lines 1, 3, 5, 7, 8
});

// Branch Coverage
// Every decision point is tested for both true and false
function validateUser(user) {
    if (user.age >= 18) {           // Branch 1: true/false
        if (user.email) {           // Branch 2: true/false
            return true;
        }
    }
    return false;
}

// Test all branch combinations
test('valid adult with email', () => {
    const user = { age: 25, email: 'test@example.com' };
    expect(validateUser(user)).toBe(true); // Branch 1: true, Branch 2: true
});

test('valid adult without email', () => {
    const user = { age: 25, email: null };
    expect(validateUser(user)).toBe(false); // Branch 1: true, Branch 2: false
});

test('minor with email', () => {
    const user = { age: 17, email: 'test@example.com' };
    expect(validateUser(user)).toBe(false); // Branch 1: false
});

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Boundary Value Analysis

Master boundary value analysis to test edge cases and boundary conditions

Content by: Yash Sanghavi

Software Testing & QA Specialist

Connect

Boundary Value Analysis Principles

•Focus on boundary values of input ranges
•Test values just inside and outside boundaries
•Most errors occur at boundaries
•Test minimum, maximum, and edge values
•Apply to both valid and invalid ranges

Boundary Value Examples

Code Example

// Example: Age validation (18-65)
function testAgeBoundaries() {
    // Valid range: 18-65
    // Test boundaries: 17, 18, 19, 64, 65, 66
    
    // Just below minimum (invalid)
    expect(validateAge(17)).toBe(false);
    
    // Minimum valid
    expect(validateAge(18)).toBe(true);
    
    // Just above minimum (valid)
    expect(validateAge(19)).toBe(true);
    
    // Just below maximum (valid)
    expect(validateAge(64)).toBe(true);
    
    // Maximum valid
    expect(validateAge(65)).toBe(true);
    
    // Just above maximum (invalid)
    expect(validateAge(66)).toBe(false);
}

// Example: Password length (8-20 characters)
function testPasswordBoundaries() {
    // Valid range: 8-20 characters
    // Test boundaries: 7, 8, 9, 19, 20, 21
    
    // Just below minimum (invalid)
    expect(validatePassword("1234567")).toBe(false); // 7 chars
    
    // Minimum valid
    expect(validatePassword("12345678")).toBe(true); // 8 chars
    
    // Just above minimum (valid)
    expect(validatePassword("123456789")).toBe(true); // 9 chars
    
    // Just below maximum (valid)
    expect(validatePassword("1234567890123456789")).toBe(true); // 19 chars
    
    // Maximum valid
    expect(validatePassword("12345678901234567890")).toBe(true); // 20 chars
    
    // Just above maximum (invalid)
    expect(validatePassword("123456789012345678901")).toBe(false); // 21 chars
}

// Example: Array bounds
function testArrayBoundaries() {
    const arr = [1, 2, 3, 4, 5]; // Length: 5, valid indices: 0-4
    
    // Just below minimum (invalid)
    expect(() => arr[-1]).toThrow();
    
    // Minimum valid
    expect(arr[0]).toBe(1);
    
    // Just above minimum (valid)
    expect(arr[1]).toBe(2);
    
    // Just below maximum (valid)
    expect(arr[3]).toBe(4);
    
    // Maximum valid
    expect(arr[4]).toBe(5);
    
    // Just above maximum (invalid)
    expect(arr[5]).toBeUndefined();
}

Swipe to see more code

// Example: Age validation (18-65)
function testAgeBoundaries() {
    // Valid range: 18-65
    // Test boundaries: 17, 18, 19, 64, 65, 66
    
    // Just below minimum (invalid)
    expect(validateAge(17)).toBe(false);
    
    // Minimum valid
    expect(validateAge(18)).toBe(true);
    
    // Just above minimum (valid)
    expect(validateAge(19)).toBe(true);
    
    // Just below maximum (valid)
    expect(validateAge(64)).toBe(true);
    
    // Maximum valid
    expect(validateAge(65)).toBe(true);
    
    // Just above maximum (invalid)
    expect(validateAge(66)).toBe(false);
}

// Example: Password length (8-20 characters)
function testPasswordBoundaries() {
    // Valid range: 8-20 characters
    // Test boundaries: 7, 8, 9, 19, 20, 21
    
    // Just below minimum (invalid)
    expect(validatePassword("1234567")).toBe(false); // 7 chars
    
    // Minimum valid
    expect(validatePassword("12345678")).toBe(true); // 8 chars
    
    // Just above minimum (valid)
    expect(validatePassword("123456789")).toBe(true); // 9 chars
    
    // Just below maximum (valid)
    expect(validatePassword("1234567890123456789")).toBe(true); // 19 chars
    
    // Maximum valid
    expect(validatePassword("12345678901234567890")).toBe(true); // 20 chars
    
    // Just above maximum (invalid)
    expect(validatePassword("123456789012345678901")).toBe(false); // 21 chars
}

// Example: Array bounds
function testArrayBoundaries() {
    const arr = [1, 2, 3, 4, 5]; // Length: 5, valid indices: 0-4
    
    // Just below minimum (invalid)
    expect(() => arr[-1]).toThrow();
    
    // Minimum valid
    expect(arr[0]).toBe(1);
    
    // Just above minimum (valid)
    expect(arr[1]).toBe(2);
    
    // Just below maximum (valid)
    expect(arr[3]).toBe(4);
    
    // Maximum valid
    expect(arr[4]).toBe(5);
    
    // Just above maximum (invalid)
    expect(arr[5]).toBeUndefined();
}

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Equivalence Partitioning

Learn equivalence partitioning to reduce test cases while maintaining coverage

Content by: Paras Dadhania

Software Testing & QA Specialist

Connect

Equivalence Partitioning Principles

•Divide input data into equivalent groups
•All values in a partition behave similarly
•Test one value from each partition
•Reduces number of test cases
•Maintains test coverage

Equivalence Partitioning Examples

Code Example

// Example: Age validation (18-65)
function testAgeEquivalencePartitions() {
    // Valid partition: 18-65
    // Invalid partitions: <18, >65, non-numeric
    
    // Test one value from valid partition
    expect(validateAge(25)).toBe(true); // Representative of 18-65
    
    // Test one value from each invalid partition
    expect(validateAge(17)).toBe(false); // Representative of <18
    expect(validateAge(66)).toBe(false); // Representative of >65
    expect(validateAge("abc")).toBe(false); // Representative of non-numeric
}

// Example: Grade calculation
function testGradeEquivalencePartitions() {
    // A: 90-100
    // B: 80-89
    // C: 70-79
    // D: 60-69
    // F: 0-59
    // Invalid: <0, >100, non-numeric
    
    // Test one value from each valid partition
    expect(getGrade(95)).toBe('A'); // Representative of 90-100
    expect(getGrade(85)).toBe('B'); // Representative of 80-89
    expect(getGrade(75)).toBe('C'); // Representative of 70-79
    expect(getGrade(65)).toBe('D'); // Representative of 60-69
    expect(getGrade(55)).toBe('F'); // Representative of 0-59
    
    // Test invalid partitions
    expect(getGrade(-5)).toBe('Invalid'); // Representative of <0
    expect(getGrade(105)).toBe('Invalid'); // Representative of >100
    expect(getGrade("abc")).toBe('Invalid'); // Representative of non-numeric
}

// Example: Email validation
function testEmailEquivalencePartitions() {
    // Valid: proper email format
    // Invalid: missing @, missing domain, missing username, etc.
    
    // Test valid partition
    expect(validateEmail("user@example.com")).toBe(true);
    
    // Test invalid partitions
    expect(validateEmail("userexample.com")).toBe(false); // Missing @
    expect(validateEmail("@example.com")).toBe(false); // Missing username
    expect(validateEmail("user@")).toBe(false); // Missing domain
    expect(validateEmail("user@example")).toBe(false); // Missing TLD
    expect(validateEmail("")).toBe(false); // Empty string
}

Swipe to see more code

// Example: Age validation (18-65)
function testAgeEquivalencePartitions() {
    // Valid partition: 18-65
    // Invalid partitions: <18, >65, non-numeric
    
    // Test one value from valid partition
    expect(validateAge(25)).toBe(true); // Representative of 18-65
    
    // Test one value from each invalid partition
    expect(validateAge(17)).toBe(false); // Representative of <18
    expect(validateAge(66)).toBe(false); // Representative of >65
    expect(validateAge("abc")).toBe(false); // Representative of non-numeric
}

// Example: Grade calculation
function testGradeEquivalencePartitions() {
    // A: 90-100
    // B: 80-89
    // C: 70-79
    // D: 60-69
    // F: 0-59
    // Invalid: <0, >100, non-numeric
    
    // Test one value from each valid partition
    expect(getGrade(95)).toBe('A'); // Representative of 90-100
    expect(getGrade(85)).toBe('B'); // Representative of 80-89
    expect(getGrade(75)).toBe('C'); // Representative of 70-79
    expect(getGrade(65)).toBe('D'); // Representative of 60-69
    expect(getGrade(55)).toBe('F'); // Representative of 0-59
    
    // Test invalid partitions
    expect(getGrade(-5)).toBe('Invalid'); // Representative of <0
    expect(getGrade(105)).toBe('Invalid'); // Representative of >100
    expect(getGrade("abc")).toBe('Invalid'); // Representative of non-numeric
}

// Example: Email validation
function testEmailEquivalencePartitions() {
    // Valid: proper email format
    // Invalid: missing @, missing domain, missing username, etc.
    
    // Test valid partition
    expect(validateEmail("user@example.com")).toBe(true);
    
    // Test invalid partitions
    expect(validateEmail("userexample.com")).toBe(false); // Missing @
    expect(validateEmail("@example.com")).toBe(false); // Missing username
    expect(validateEmail("user@")).toBe(false); // Missing domain
    expect(validateEmail("user@example")).toBe(false); // Missing TLD
    expect(validateEmail("")).toBe(false); // Empty string
}

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Previous Module

Module 1: Software Testing Fundamentals

Next Module

Module 3: Test Management & Documentation

Ready for the Next Module?

Continue your learning journey and master the next set of concepts.

Continue to Module 3

Module 2: Manual Testing Techniques

Manual Testing Techniques

Select Topics Overview

Test Case Design & Writing

Black Box Testing Techniques

White Box Testing Techniques

Boundary Value Analysis

Equivalence Partitioning

Test Case Design & Writing

Black Box Testing Techniques

White Box Testing Techniques

Boundary Value Analysis

Equivalence Partitioning

Test Case Design & Writing

Test Case Components

Test Case Template

🎯 Practice Exercise

Black Box Testing Techniques

Black Box Testing Principles

Black Box Testing Techniques

🎯 Practice Exercise

White Box Testing Techniques

White Box Testing Principles

Code Coverage Types

🎯 Practice Exercise

Boundary Value Analysis

Boundary Value Analysis Principles

Boundary Value Examples

🎯 Practice Exercise

Equivalence Partitioning

Equivalence Partitioning Principles

Equivalence Partitioning Examples

🎯 Practice Exercise

Module 1: Software Testing Fundamentals

Module 3: Test Management & Documentation

Ready for the Next Module?