Edge Case Testing — Test edge cases and boundary conditions...

SECTION 1

Historical Context & Motivation

Software bugs have been around as long as software itself. Some of the most catastrophic failures in computing history weren't caused by obviously broken logic — they were caused by inputs that nobody thought to test. An edge case is an input or scenario that sits at the extreme boundary of what a program is expected to handle. When developers skip testing these extremes, real-world users eventually stumble into them, often with costly results.

The history of software testing is really a history of learning from mistakes. Each major incident pushed the industry toward more rigorous, systematic approaches — especially around boundary conditions. Let's look at some key moments that shaped how we think about edge case testing today.

1962

Mariner 1 Spacecraft Lost

A missing hyphen in a guidance formula caused NASA's Mariner 1 probe to veer off course and self-destruct. This $18.5 million failure highlighted how a single overlooked detail could doom a mission.

1996

Ariane 5 Rocket Explosion

The European Space Agency's Ariane 5 rocket exploded 37 seconds after launch because a 64-bit number was converted to a 16-bit integer. The value exceeded the maximum the smaller type could hold — a classic boundary condition failure.

2000

Y2K Bug

Programmers had stored years as two digits to save memory. When the year rolled from '99' to '00', many systems interpreted it as 1900. The world spent billions fixing an edge case in date representation.

2010s

Rise of Automated Testing

Frameworks like Jest and Mocha made it easy for JavaScript developers to write test suites. The community embraced systematic boundary testing as a core practice, catching edge cases before they reached users.

Each of these incidents shares a common thread: the main functionality worked fine under normal conditions, but extreme or unusual inputs exposed fatal flaws. This brings us to the central question of this lesson: how do you systematically identify and test the inputs most likely to break your code?

SECTION 2

Core Principles & Definitions

Before you can test edge cases, you need to understand what they are and why they matter. At its core, edge case testing is about asking: "What happens if someone passes my function something I didn't expect?" This section introduces the foundational ideas that make systematic edge case testing possible.

Edge Case

An input or condition at the extreme end of what your code should handle. Examples include empty strings, zero, negative numbers, or arrays with only one element.

Boundary Condition

The exact point where your code's behavior changes. If a function accepts ages 0–120, the boundaries are 0, 120, and the values just outside: −1 and 121.

Equivalence Partitioning

Dividing all possible inputs into groups (partitions) that should behave the same way. You only need to test one value from each partition, plus the boundaries between them.

Boundary Value Analysis

A technique where you test values at, just below, and just above each boundary. Most bugs cluster around these transition points, so this approach catches problems efficiently.

Defensive Programming

Writing code that gracefully handles unexpected inputs instead of crashing. Edge case testing verifies that your defenses actually work as intended.

✦ KEY TAKEAWAY

Think of edge case testing like checking a fence for weak spots. A fence might look solid across its entire length, but the posts at the very ends and the corners are where it's most likely to come loose. In code, the boundaries between valid and invalid inputs are exactly where bugs love to hide. You don't need to test every possible input — just the ones at the edges.

SECTION 3

Visual Explanation — The Boundary Map

To understand where edge cases live, it helps to visualize the full range of inputs your function might receive. Imagine a number line that shows every possible value. Your function divides this line into regions — valid inputs, invalid inputs, and the critical boundary points in between. The diagram below shows this concept for a function that accepts an age between 0 and 120.

The amber dots mark the boundary values (0 and 120). The pink dots (−1, 121) sit just outside the valid range and should be rejected. The cyan dots (1, 119) sit just inside. Testing all six of these values, plus a typical value like 60, gives you strong coverage with minimal effort.

Notice how the diagram highlights a small set of strategic test values rather than every possible number. This is the power of boundary value analysis — you don't need to test ages 2, 3, 4, 5, and so on. If your code handles 0, 1, 60, 119, 120, −1, and 121 correctly, you can be reasonably confident it handles everything in between.

SECTION 4

How It Works — A Systematic Approach

Edge case testing is not about randomly guessing what might break your code. It follows a repeatable process that you can apply to any JavaScript function. The key insight is that every function has an input domain — the set of all possible values it could receive — and your job is to identify the most dangerous points in that domain.

The Four-Step Process

Step 1 — Identify the input domain. What types of values can your function receive? Numbers, strings, arrays, objects, or a mix? What range is considered valid?
Step 2 — Find the partitions. Divide the input domain into groups that should behave the same way. For a grading function, partitions might be: below 0 (invalid), 0–59 (F), 60–69 (D), 70–79 (C), 80–89 (B), 90–100 (A), above 100 (invalid).
Step 3 — Test the boundaries. For each partition boundary, test the value at the boundary, one step below it, and one step above it. These are where off-by-one errors lurk.
Step 4 — Add special values. Test JavaScript-specific edge cases: null, undefined, NaN, empty strings, empty arrays, and very large or very small numbers.

Common JavaScript Edge Cases

JavaScript-specific edge cases by data type

Data Type	Common Edge Cases	Why They Break Things
Numbers	`0`, `-0`, `NaN`, `Infinity`, `-Infinity`, `Number.MAX_SAFE_INTEGER`	Zero is falsy, NaN !== NaN, and very large numbers lose precision
Strings	`""`, `" "` (whitespace), very long strings, special characters	Empty strings are falsy; whitespace-only strings are truthy but may be logically empty
Arrays	`[]`, single-element arrays, arrays with `undefined` holes	Empty arrays are truthy but have length 0; index-based access returns undefined
Objects	`null`, `undefined`, `{}`, nested nulls	Accessing properties on null/undefined throws TypeError
Booleans / Mixed	`false`, `0`, `"0"`, type coercion traps	JavaScript's loose equality (==) produces surprising results with mixed types

⚠️ JavaScript Quirk Alert

In JavaScript, typeof null returns "object" — a famous bug from the language's earliest days that was never fixed. This means you can't rely on typeof alone to guard against null values. Always check for null explicitly before accessing properties.

SECTION 5

Categories of Edge Cases

Not all edge cases are created equal. They fall into distinct categories, and experienced developers build a mental checklist they run through for every function they write or test. The diagram below organizes these categories into a decision tree that you can follow whenever you're writing tests.

This decision tree organizes edge cases by input type. Start at the top, follow the branch matching your function's input, and test each leaf node. The green bar at the bottom reminds you that null, undefined, and wrong-type inputs should always be tested regardless of what your function expects.

The decision tree above gives you a repeatable checklist. Whenever you write a new function, ask yourself which branch applies, and then write at least one test for each leaf node. Over time, this becomes second nature — you'll start spotting potential edge cases as you write the code itself, not just when you test it afterward.

💡 Pro Tip

A good rule of thumb is the ZOMBIES mnemonic: Zero, One, Many, Boundaries, Interfaces, Exceptions, Simple. For each parameter, ask: what happens with zero items, one item, many items? Then check boundaries, test how components interact, handle exceptions, and start with the simplest case.

SECTION 6

Worked Example — Testing a getGrade Function

Let's walk through a complete example. Suppose you've written a JavaScript function called getGrade(score) that takes a numeric score from 0 to 100 and returns a letter grade. We'll systematically identify the edge cases, write tests, and see what breaks.

Systematically Testing getGrade(score)

Step 1 — Understand the FunctionHere's the function we're testing:


function getGrade(score) {
  if (score >= 90) return 'A';
  if (score >= 80) return 'B';
  if (score >= 70) return 'C';
  if (score >= 60) return 'D';
  return 'F';
}

The function assumes score is a number between 0 and 100. But does it actually enforce that?

Input domain: numbers; partitions at 60, 70, 80, 90

Step 2 — Identify Partitions and BoundariesUsing equivalence partitioning, we get six regions: below 0 (invalid), 0–59 (F), 60–69 (D), 70–79 (C), 80–89 (B), 90–100 (A), and above 100 (should be invalid). The boundary values are: 0, 59, 60, 69, 70, 79, 80, 89, 90, 100. Just outside these are −1 and 101.

12+ boundary test values identified

Step 3 — Write Boundary TestsHere's how you'd write these in Jest:


describe('getGrade', () => {
  // Boundary: F/D transition
  test('score 59 returns F', () => expect(getGrade(59)).toBe('F'));
  test('score 60 returns D', () => expect(getGrade(60)).toBe('D'));

  // Boundary: D/C transition
  test('score 69 returns D', () => expect(getGrade(69)).toBe('D'));
  test('score 70 returns C', () => expect(getGrade(70)).toBe('C'));

  // Boundary: C/B transition
  test('score 79 returns C', () => expect(getGrade(79)).toBe('C'));
  test('score 80 returns B', () => expect(getGrade(80)).toBe('B'));

  // Boundary: B/A transition
  test('score 89 returns B', () => expect(getGrade(89)).toBe('B'));
  test('score 90 returns A', () => expect(getGrade(90)).toBe('A'));
});

Each test checks a value right on each side of a boundary.

8 boundary tests covering all grade transitions

Step 4 — Add Special Value TestsNow let's test the values the developer probably didn't think about:


// Edge cases beyond valid range
test('score -1 should be handled', () => {
  expect(getGrade(-1)).toBe('F'); // Is this correct? Or should it throw?
});
test('score 101 returns A', () => {
  expect(getGrade(101)).toBe('A'); // Bug! 101 shouldn't be a valid score
});

// JavaScript special values
test('null input', () => expect(getGrade(null)).toBe('F'));
test('undefined input', () => expect(getGrade(undefined)).toBe('F'));
test('NaN input', () => expect(getGrade(NaN)).toBe('F'));
test('string input', () => expect(getGrade('ninety')).toBe('F'));

Notice how getGrade(101) returns 'A' instead of raising an error. And getGrade(null) also returns 'F' because null >= 90 is false in JavaScript. These tests reveal that the function needs input validation.

Bugs found: no validation for out-of-range values or non-numeric inputs

Step 5 — Fix and Re-testHere's the improved version with defensive programming:


function getGrade(score) {
  if (typeof score !== 'number' || Number.isNaN(score)) {
    throw new TypeError('Score must be a number');
  }
  if (score < 0 || score > 100) {
    throw new RangeError('Score must be between 0 and 100');
  }
  if (score >= 90) return 'A';
  if (score >= 80) return 'B';
  if (score >= 70) return 'C';
  if (score >= 60) return 'D';
  return 'F';
}

Now re-running the edge case tests confirms the function handles all boundaries and special values correctly.

All 14+ tests pass after adding input validation

SECTION 7

Strengths, Limitations & Comparisons

Edge case testing is one of the most effective techniques in a developer's testing toolkit, but it doesn't cover everything. Understanding what it does well and where it falls short helps you combine it with other testing strategies for maximum coverage.

Strengths and limitations of edge case testing

Aspect	Strengths	Limitations
Bug Detection	Catches the most common bugs (off-by-one errors, null references, type coercion) with relatively few tests	Cannot catch bugs in complex business logic that don't involve boundaries
Efficiency	Tests a small number of strategic values instead of exhaustive inputs; great return on time invested	Requires you to correctly identify where boundaries are; missed boundaries mean missed bugs
Automation	Easy to automate with Jest or other frameworks; tests run in milliseconds	Some edge cases (race conditions, network timeouts) are hard to simulate in unit tests
Code Quality	Forces you to think about input validation, making your code more robust overall	Over-testing trivial boundaries can add maintenance burden without adding value
Coverage	Works for all data types and most function signatures; universally applicable	Doesn't test integration between modules or real user workflows

✦ KEY TAKEAWAY

Edge case testing is like checking all the doors and windows of a house before a storm. It's the most efficient way to find vulnerabilities, but it won't tell you if the plumbing inside is broken. Combine it with integration tests (testing how parts work together) and end-to-end tests (testing the whole user flow) for full confidence in your code.

SECTION 8

Connection to Advanced Testing Techniques

The edge case testing skills you've learned form the foundation for more advanced testing techniques used in professional software development. As you grow as a programmer, you'll encounter approaches that build directly on boundary value analysis and equivalence partitioning.

From edge case testing to advanced techniques

What You Know Now	Advanced Technique	How It Extends Your Knowledge
Manually choosing edge case values	Property-Based Testing	Libraries like fast-check automatically generate hundreds of random inputs, including edge cases, and verify that properties you define always hold true
Testing one function at a time	Fuzz Testing	Automated tools bombard your entire program with random, malformed, or extreme inputs to find crashes you'd never think to test manually
Writing tests after writing code	Test-Driven Development (TDD)	You write edge case tests first, before writing the function. The tests define what the function should do, and you write code until all tests pass
Checking that tests pass	Mutation Testing	Tools deliberately introduce small bugs (mutations) into your code. If your edge case tests don't catch them, your tests aren't thorough enough

You don't need to learn all of these right now. The important thing is that boundary thinking — the habit of asking "what's the weirdest input this could receive?" — is a skill that carries over to every level of software development. Professional engineers at companies like Google and Netflix use exactly the same mental model you're learning here, just with more sophisticated tools.

SECTION 9

Practice Problems

PROBLEM 1 — CONCEPTUAL

A function isTeenager(age) returns true for ages 13 through 19, inclusive, and false otherwise. List at least six specific values you should test to cover all boundary conditions. Explain why each value is important.

PROBLEM 2 — BASIC CALCULATION

Given this function:


function clamp(value, min, max) {
  if (value < min) return min;
  if (value > max) return max;
  return value;
}

Write three Jest test cases: one for a value below min, one exactly at min, and one exactly at max. Use min = 0 and max = 255.

PROBLEM 3 — INTERMEDIATE

Consider a function findMax(arr) that returns the largest number in an array. Using the ZOMBIES mnemonic (Zero, One, Many, Boundaries, Interfaces, Exceptions, Simple), list one specific test case for at least five of the seven letters. Write the expected result for each.

PROBLEM 4 — APPLIED

You are building a signup form validator. The function validateUsername(name) must enforce these rules: the username must be a string, 3 to 20 characters long, and contain only letters, numbers, and underscores. Write a complete Jest test suite with at least eight tests covering boundary conditions and edge cases for this function.

PROBLEM 5 — CRITICAL THINKING

JavaScript's Array.prototype.sort() method converts elements to strings by default, so [10, 9, 2].sort() returns [10, 2, 9] (string order). A student writes a wrapper function numSort(arr) that uses arr.sort((a, b) => a - b) to fix this. Design edge case tests that would reveal hidden bugs in this approach. Think about what kinds of array contents could cause a - b to produce unexpected results.

SUMMARY

Lesson Summary

Edge case testing is the practice of deliberately testing the extreme and unusual inputs that are most likely to break your code. Rather than testing every possible value, you use equivalence partitioning to divide inputs into groups and boundary value analysis to focus on the exact points where behavior changes. For every function, you should test values at each boundary, one step inside, and one step outside. In JavaScript, you must also test special values like null, undefined, NaN, empty strings, and empty arrays.

The ZOMBIES mnemonic (Zero, One, Many, Boundaries, Interfaces, Exceptions, Simple) gives you a reliable checklist for identifying edge cases in any function. Combining edge case testing with defensive programming — adding input validation that throws meaningful errors for invalid inputs — makes your code robust against real-world misuse. This foundational skill leads directly into advanced techniques like property-based testing, fuzz testing, and test-driven development that professional developers use daily.