Equivalence partitioning and boundary value analysis in Software Engineering - Full Explanation

Introduction

Testing every possible input for software is impossible and inefficient. To solve this, testers use smart methods to pick representative inputs that catch most errors without checking everything.

Explanation

Equivalence Partitioning

This method divides all possible inputs into groups where the software should behave the same way. Instead of testing every input, testers pick one example from each group to represent it. This reduces the number of tests while still covering different input types.

Equivalence partitioning groups inputs so one test per group can represent many similar cases.

Boundary Value Analysis

Errors often happen at the edges of input ranges. This method focuses on testing values at, just below, and just above these edges. By checking these boundary values, testers find problems that might be missed by testing only typical inputs.

Boundary value analysis tests edge cases where errors are most likely to occur.

Real World Analogy

Imagine sorting mail into bins by zip code ranges. Instead of checking every address, you check one letter from each zip code range to ensure sorting works. Then, you check letters with zip codes right at the start and end of each range to catch sorting mistakes at the boundaries.

Equivalence Partitioning → Checking one letter from each zip code range to represent all addresses in that range

Boundary Value Analysis → Checking letters with zip codes at the start and end of each range to catch sorting errors at edges

Diagram

Diagram

┌─────────────────────────────┐
│       Input Range            │
│ ┌───────────┐ ┌───────────┐ │
│ │ Partition │ │ Partition │ │
│ │    1      │ │    2      │ │
│ └───────────┘ └───────────┘ │
│   ↑             ↑           │
│  Test          Test         │
│  one value     one value    │
│   from          from        │
│  each part     each part    │
│                             │
│ Boundaries:                 │
│  ┌─┐   ┌─┐                 │
│  │*│   │*│                 │
│  └─┘   └─┘                 │
│  Test values at edges       │
└─────────────────────────────┘

This diagram shows input divided into partitions with one test value each and highlights testing at boundary edges.

Key Facts

Equivalence Partition → A group of inputs expected to be treated the same by the software.

Boundary Value → An input value at the edge of an input range where errors often occur.

Representative Test Case → A single input chosen from an equivalence partition to test that group.

Off-by-One Error → A common bug where boundary values are handled incorrectly.

Common Confusions

Believing testing one value from the entire input is enough.

Believing testing one value from the entire input is enough. Each equivalence partition can behave differently, so one test per partition is needed, not just one overall.

Thinking boundary value analysis tests only the exact boundary values.

Thinking boundary value analysis tests only the exact boundary values. It tests values just below, at, and just above the boundaries to catch edge errors.

Summary

Equivalence partitioning reduces tests by grouping inputs that should behave the same and testing one from each group.

Boundary value analysis focuses on testing inputs at the edges of ranges where errors are most likely.

Together, these methods help find bugs efficiently without testing every possible input.

Practice

1. Which of the following best describes equivalence partitioning in software testing?

easy

A. Running all possible input combinations exhaustively

B. Testing only the maximum input value of a range

C. Checking the software's response to invalid inputs only

D. Dividing input data into groups where test cases represent each group

Solution

1. Step 1: Understand equivalence partitioning concept

   Equivalence partitioning divides inputs into groups where all inputs in a group are expected to behave similarly.

2. Step 2: Match description to options

   Dividing input data into groups where test cases represent each group correctly states this grouping approach. Other options describe different testing ideas.

3. Final Answer:

   Dividing input data into groups where test cases represent each group -> Option D

4. Quick Check:

   Equivalence partitioning = Group inputs [OK]

Hint: Group inputs by behavior to reduce tests [OK]

Common Mistakes:

• Confusing equivalence partitioning with boundary value analysis
• Thinking it tests only invalid inputs
• Assuming it requires exhaustive testing

2. Which of the following is the correct boundary value test inputs for a field accepting integers from 1 to 10 inclusive?

easy

A. 1, 2, 9, 10

B. 1, 5, 10

C. 0, 1, 10, 11

D. 0, 5, 10

Solution

1. Step 1: Identify boundary values for range 1 to 10

   Boundaries are the edges: minimum (1), maximum (10), and just outside edges (0 and 11).

2. Step 2: Check options for correct boundary inputs

   0, 1, 10, 11 includes 0 (just below min), 1 (min), 10 (max), and 11 (just above max), which is correct for boundary testing.

3. Final Answer:

   0, 1, 10, 11 -> Option C

4. Quick Check:

   Boundary values = edges and just outside [OK]

Hint: Test edges plus one inside and outside values [OK]

Common Mistakes:

• Testing only valid inputs ignoring just outside boundaries
• Choosing random middle values instead of edges
• Missing one side of the boundary

3. Consider a function that accepts an integer input from 1 to 5 inclusive. Which set of test inputs covers both equivalence partitioning and boundary value analysis?

medium

A. [0, 1, 3, 5, 6]

B. [1, 2, 3, 4, 5]

C. [1, 5]

D. [2, 3, 4]

Solution

1. Step 1: Identify equivalence partitions and boundaries

   Partitions: invalid below (<=0), valid (1-5), invalid above (>=6). Boundaries: 1 and 5 plus just outside 0 and 6.

2. Step 2: Check which option covers all partitions and boundaries

   [0, 1, 3, 5, 6] includes 0 (below), 1 (min boundary), 3 (valid middle), 5 (max boundary), and 6 (above), covering partitions and boundaries.

3. Final Answer:

   [0, 1, 3, 5, 6] -> Option A

4. Quick Check:

   Partitions + boundaries = test edges and groups [OK]

Hint: Include invalid, valid, and boundary values [OK]

Common Mistakes:

• Ignoring invalid partitions
• Testing only boundaries without middle values
• Choosing only valid inputs

4. A tester wrote these test inputs for a field accepting values 10 to 20 inclusive: [9, 10, 15, 20, 21]. The test failed to catch a bug at input 21. What is the likely mistake?

medium

A. They only tested valid inputs and ignored invalid ones

B. They did not include invalid inputs below 10

C. They missed testing the exact boundary values

D. They did not test the boundary just above the max value correctly

Solution

1. Step 1: Analyze test inputs and bug location

   Inputs include 9 (below min), 10 (min), 15 (middle), 20 (max), and 21 (just above max). Bug at 21 means boundary above max was tested.

2. Step 2: Identify mistake causing bug miss

   Since bug was missed at 21, likely the test did not properly check or handle the boundary just above max, possibly due to incorrect validation or test setup.

3. Final Answer:

   They only tested valid inputs and ignored invalid ones -> Option A

4. Quick Check:

   Boundary above max must be tested carefully [OK]

Hint: Check boundaries just outside valid range carefully [OK]

Common Mistakes:

• Assuming testing 21 is enough without checking handling
• Ignoring off-by-one errors at boundaries
• Not validating test setup correctness

5. You have a form field that accepts ages from 18 to 60 inclusive. Using equivalence partitioning and boundary value analysis, which of the following test sets is the most effective to detect input errors?

hard

A. [18, 19, 20, 59, 60]

B. [17, 18, 30, 60, 61]

C. [18, 30, 60]

D. [16, 18, 60, 62]

Solution

1. Step 1: Define equivalence partitions and boundaries for age 18-60

   Partitions: invalid below 18, valid 18-60, invalid above 60. Boundaries: 18 (min), 60 (max), and just outside 17 and 61.

2. Step 2: Evaluate options for coverage

   [17, 18, 30, 60, 61] includes 17 (below min), 18 (min), 30 (valid middle), 60 (max), and 61 (above max), covering all partitions and boundaries effectively.

3. Final Answer:

   [17, 18, 30, 60, 61] -> Option B

4. Quick Check:

   Test invalid, valid, and boundary values for best coverage [OK]

Hint: Test just below, at, inside, and just above boundaries [OK]

Common Mistakes:

• Ignoring invalid partitions
• Testing only valid inputs
• Missing boundary values just outside range