Equivalence partitioning and boundary value analysis in Software Engineering - Step-by-Step Execution

Concept Flow - Equivalence partitioning and boundary value analysis

Start: Function accepts input with valid range

↓

Define input domain (e.g., age: 1-120)

↓

Equivalence Partitioning: Split into classes

↓

Invalid Low

↓

Pick ONE test from each partition

↓

Boundary Value Analysis: Test at edges

↓

Test: 0, 1, 2, 119, 120, 121

↓

Combine: partition + boundary tests

↓

End

This flow shows how equivalence partitioning divides inputs into classes and boundary value analysis tests at the edges of those classes to maximize defect detection with minimal test cases.

Execution Sample

Software Engineering

Function: validate_age(age) accepts integer 1-120

Equivalence Partitions:
  Partition 1 (Invalid Low):  age < 1    → test with -5
  Partition 2 (Valid):        1 <= age <= 120 → test with 25
  Partition 3 (Invalid High): age > 120  → test with 200

Boundary Values:
  Lower boundary: 0 (invalid), 1 (valid), 2 (valid)
  Upper boundary: 119 (valid), 120 (valid), 121 (invalid)

Final test set: {-5, 0, 1, 2, 25, 119, 120, 121, 200}

This sequence shows how to derive a minimal but effective test set using equivalence partitioning and boundary value analysis for an age validation function.

Analysis Table

Step	Action	Condition/Check	Result/Decision	Next Step
1	Define input domain	age must be integer 1-120	Domain identified	Create equivalence partitions
2	Create equivalence partitions	Split into valid and invalid classes	3 partitions: <1, 1-120, >120	Select one value per partition
3	Select partition test values	One representative per class	-5 (low), 25 (valid), 200 (high)	Identify boundary values
4	Identify boundary values	Edges of each partition	0, 1, 2, 119, 120, 121	Combine test sets
5	Combine partition + boundary tests	Remove duplicates	9 unique test values	Execute tests
6	Execute tests	Run validate_age() with each value	Verify pass/fail for each	Analyze results
7	Analyze results	Do results match expected behavior?	All correct → function validated	End

💡 9 well-chosen test values cover all equivalence classes and boundary conditions, catching most common defects without exhaustive testing.

State Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
partitions	None	3: <1, 1-120, >120	3 partitions	3 partitions	3 partitions
partition_tests	None	None	{-5, 25, 200}	{-5, 25, 200}	Merged into final set
boundary_tests	None	None	None	{0, 1, 2, 119, 120, 121}	Merged into final set
final_test_set	Empty	Empty	3 values	9 values	9 values tested

Key Insights - 3 Insights

Why is testing one value from each partition sufficient?

Equivalence partitioning assumes all values within a partition behave the same way. If age=25 passes validation, age=50 will too. Testing one representative per class finds the same defects as testing all values in that class.

Why do most bugs occur at boundary values?

Off-by-one errors are the most common coding mistakes. A condition like age >= 1 might be incorrectly coded as age > 1, which only fails at the boundary value 1. Boundary value analysis specifically targets these edge cases.

How many test cases does this technique save compared to exhaustive testing?

For age 1-120, exhaustive testing needs 120+ values for valid inputs alone. Equivalence partitioning plus boundary value analysis needs only 9 tests total, yet catches the same classes of defects.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. How many equivalence partitions are created for validate_age()?

A 2 partitions

B 3 partitions

C 4 partitions

D 6 partitions

💡 Hint

Check the 'Result/Decision' column in step 2.

According to the variable_tracker, how many boundary test values are identified?

A 2 values

B 4 values

C 6 values

D 9 values

💡 Hint

Look at the boundary_tests row in the 'After Step 4' column.

Why is 0 included as a boundary test value but not -1?

A 0 is the value immediately below the valid lower boundary of 1

B Negative numbers cannot be tested

C 0 is always a special case in programming

D -1 is already covered by the partition test value -5

💡 Hint

Boundary value analysis tests values immediately at and around the boundary, not arbitrary values far from it.

Concept Snapshot

Equivalence partitioning splits the input domain into classes with expected similar behavior.
Boundary value analysis tests at the edges of each partition.
Combined, they produce a minimal test set that catches most common defects.
For age 1-120: 3 partitions + 6 boundary values = 9 tests instead of 120+.
Most bugs cluster at boundaries due to off-by-one errors.

Full Transcript

This visual execution shows how equivalence partitioning and boundary value analysis work together to create efficient test sets. For a function that validates age between 1 and 120, we first create three equivalence partitions: invalid low, valid, and invalid high. We pick one representative value from each partition. Then boundary value analysis adds test values at the edges: 0, 1, 2 at the lower boundary and 119, 120, 121 at the upper boundary. The combined set of 9 tests covers all input classes and boundary conditions, catching the same defects that hundreds of random tests might miss.

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