Software Testing

Intermediate path · lesson 1 of 19

IntermediateTest design7 min readUpdated November 12, 2026

Equivalence partitioning and boundary values: beyond the basics

Real features have several inputs, hidden limits and boundaries the screen never shows. Here's how to combine partitions without testing every combination, find the partitions nobody wrote down and measure what you've covered.

On this page

Key takeaways

  • With several inputs, aim first for each choice coverage: every partition of every input appears in at least one test. Add combinations only where rules interact.
  • Look for partitions that aren't in the requirement: output partitions and internal limits like column sizes, page sizes and number types.
  • Some boundaries hide below the surface: bytes vs characters, rounding of money, time zones and summer time. Document your partitions so coverage can be measured and reviewed.

Where this picks up

This article assumes you know the basics of equivalence partitioning and boundary value analysis: splitting one input into partitions and testing on and next to each edge.

Real features are messier. They have several inputs at once, rules that depend on each other and limits nobody wrote down. That's where these techniques need more care.

When inputs combine

A shop calculates shipping from three inputs:

InputPartitions
DestinationDomestic, EU, Outside EU
WeightUp to 2 kg, 2–10 kg, Over 10 kg
CustomerStandard, Premium

Testing every combination means 3 × 3 × 2 = 18 tests. Add two more inputs and it's hundreds.

Each choice coverage

The ISTQB syllabus describes the simplest criterion for several inputs: each choice coverage. Every partition of every input must appear in at least one test. For this example, three tests are enough:

TestDestinationWeightCustomer
1DomesticUp to 2 kgStandard
2EU2–10 kgPremium
3Outside EUOver 10 kgStandard

It's cheap, and it proves each partition is handled at all. But it can't find bugs that only appear in a specific combination.

When rules interact, combine on purpose

Now read the business rule: "Premium customers get free shipping, domestic only." Destination and customer type now interact. Test 2 checks Premium for the EU, which says nothing about whether domestic Premium orders are really free.

So add targeted combinations where the rules say inputs depend on each other:

  • Premium + Domestic → free
  • Premium + EU → paid
  • Standard + Domestic → paid

When many inputs interact, tables of rules (decision tables) and pairwise testing, which covers every pair of values with far fewer tests than every combination, are the next techniques to learn.

Partitions nobody wrote down

Output partitions

Partitions don't only come from inputs. Look at the outputs too: tax brackets, shipping bands, loyalty tiers, error messages, the different screens a user can land on.

For each distinct output, ask: "Which input produces this?" If you can't find a test that reaches an output, either you've missed a partition or the output is unreachable. Both are worth knowing.

Internal limits

The system has limits the screen doesn't show. Each one creates a hidden boundary:

  • Storage sizes: a database column that holds 50 characters, or 50 bytes.
  • Number types: a 32-bit integer can't go above 2,147,483,647. An ID or a counter that grows past it fails.
  • Page sizes: if a list shows 20 items per page, test 20 and 21 items, plus an empty list.
  • Batch and timeout limits: an export that handles 10,000 rows; a session that expires after 30 minutes.

Ask developers about them, or read the API documentation and database schema. A question like "what's the column size behind this field?" often finds a bug before any test runs.

Boundaries that hide below the surface

Characters vs bytes

"Maximum 20 characters" sounds clear. But computers often count bytes, and in the common UTF-8 encoding, characters have different sizes:

TextCharactersUTF-8 bytes
a11
ș (Romanian s-comma)12
😀14

If the field counts characters but the database counts bytes, a 20-letter name with diacritics may be accepted on screen and then rejected or cut off when saved. Test the boundary with plain ASCII and with multi-byte characters.

Money and rounding

Most programming languages store decimals in binary floating point, so 0.1 + 0.2 gives 0.30000000000000004. A total that should be exactly 50.00 may end up as 49.999999…, just below a free-shipping threshold.

Rounding rules matter too. Half up, half to even ("banker's rounding") and truncation give different results for the same value. Test thresholds with totals built from several items and discounts, not just typed-in round numbers.

Time

  • Midnight in which time zone? An offer that ends "at midnight" ends at different moments for the server, the database and the user.
  • Summer time. In Romania, clocks jump from 03:00 to 04:00 on the last Sunday of March, so 03:30 doesn't exist that day. On the last Sunday of October, 03:00–04:00 happens twice. A day can have 23 or 25 hours.
  • End of period. The 31st of a month, 29 February, the last day of the year.

A boundary nobody saw for 22 months

Real-world example · Vancouver Stock Exchange, 1982–1983An index that lost half its value to rounding

The Vancouver Stock Exchange launched a new index in January 1982, starting at 1,000. It was recalculated thousands of times a day, and each time the result was truncated to three decimal places, not rounded.

Each truncation lost a tiny fraction of a point. Over thousands of updates a day, the losses added up. By November 1983 the index stood at about 525, even though the market hadn't fallen like that.

When the exchange recalculated it correctly, the index jumped to about 1,099.

Lesson: every single calculation was "almost right". The bug lived in a boundary you can't see on screen: the fourth decimal place, repeated thousands of times. Tests with realistic sequences of operations, not just single values, would have shown the drift.

Measuring and documenting coverage

ISTQB defines coverage for these techniques simply:

  • Partition coverage = partitions tested ÷ partitions identified.
  • Boundary coverage = boundary values tested ÷ boundary values identified.

The catch is in "identified". 100% coverage only means you tested everything in your model. If the model misses a partition, the number hides it.

So write the model down, in a table in the test case, the test plan or the ticket. A reviewer can then ask "what about decimals?" or "where's the empty list?" before testing starts.

Do

Write down each input, its partitions, boundaries and the source of each rule. Ask a developer to review it: they know about the internal limits.

Don't

Report "100% boundary coverage" without saying what was modelled. A number without the model behind it gives false confidence.

Check yourself

A username field says 'up to 20 characters'. The database column is limited to 20 bytes. Which test values would reveal the mismatch?

Show answer

Test the boundary with multi-byte characters: for example, 20 Romanian letters like ș (40 bytes) or a name with emoji. Plain ASCII at 20 and 21 characters will pass and fail as expected, and hide the problem. You'd also report the mismatch itself, because someone needs to decide whether the limit is in characters or bytes.