Practice Exam: Unit Testing, TDD & Integration

Assumptions: JUnit 4; n is an int; numbers below 2 (including 0 and negative numbers) are not prime; at the start no test and no isPrime code exist.

So the path is start → GREEN → RED → GREEN. The test fails at first not because it is wrong but because, in TDD, the test is written before the code.

The specification has one boundary, “numbers less than 2 are not prime”, so the boundary values are 1 (just below), 2 (on the boundary, the smallest prime) and 3 (just above). Further cases cover the other partitions: zero and negative numbers, an even composite, an odd prime, an odd composite, and the square of a prime (which catches a loop that stops one step too early).

import org.junit.Test;
import static org.junit.Assert.*;

public class PrimeTest {

    @Test public void oneIsNotPrime()        { assertFalse(Prime.isPrime(1)); }   // just below boundary
    @Test public void twoIsPrime()           { assertTrue(Prime.isPrime(2)); }    // on the boundary
    @Test public void threeIsPrime()         { assertTrue(Prime.isPrime(3)); }    // just above boundary
    @Test public void zeroIsNotPrime()       { assertFalse(Prime.isPrime(0)); }
    @Test public void negativeIsNotPrime()   { assertFalse(Prime.isPrime(-5)); }
    @Test public void fourIsNotPrime()       { assertFalse(Prime.isPrime(4)); }   // even composite
    @Test public void sevenIsPrime()         { assertTrue(Prime.isPrime(7)); }    // odd prime
    @Test public void nineIsNotPrime()       { assertFalse(Prime.isPrime(9)); }   // odd composite
    @Test public void twentyFiveIsNotPrime() { assertFalse(Prime.isPrime(25)); }  // square of a prime
}

Every test case states its expected result (true or false), and each test is independent: none relies on state left by another.

Fake it. The only test so far expects false for 1, so the simplest code that passes is a hard-coded constant:

static boolean isPrime(int n) {
    return false;          // fake it: passes assertFalse(isPrime(1))
}

Triangulation. The next test, assertTrue(Prime.isPrime(2)), cannot be passed by a constant false, so we are back in RED. As more examples arrive (2 and 3 prime, 4 and 9 not prime), no fake can satisfy them all, and the code is generalized: a number of at least 2 is prime if no number from 2 up to its square root divides it.

static boolean isPrime(int n) {
    if (n < 2) return false;               // 1, 0 and negatives are not prime
    for (int i = 2; i <= n / i; i++) {     // same as i * i <= n, but cannot overflow
        if (n % i == 0) return false;      // found a divisor
    }
    return true;
}

Why up to the square root: if $n = a \times b$ with $a \le b$, then $a \le \sqrt{n}$, so any composite number has a divisor no larger than its square root. The condition i <= n / i is equivalent to $i^2 \le n$ for positive integers, but unlike i * i <= n it never overflows for values of n close to the largest int.

Check against the tests:

• $n = 1, 0, -5$: n < 2, so false ✓
• $n = 2$: loop condition $2 \le 2/2 = 1$ is false, loop skipped, true ✓; $n = 3$: $2 \le 1$ false, true ✓
• $n = 4$: $i = 2$, $2 \le 2$, $4 \bmod 2 = 0$, false ✓
• $n = 7$: $i = 2$, $2 \le 3$, $7 \bmod 2 = 1$; $i = 3$, $3 \le 2$ false, true ✓
• $n = 9$: $i = 2$, remainder 1; $i = 3$, $3 \le 3$, $9 \bmod 3 = 0$, false ✓
• $n = 25$: $i = 2, 3, 4$ leave remainders; $i = 5$, $5 \le 5$, $25 \bmod 5 = 0$, false ✓

All nine tests pass: GREEN.

A driver (here, the JUnit test class), because the missing module Report is the caller of isPrime: it sits above the unit. Something must take its place and call isPrime with test inputs, and a fake caller is a driver. (A stub would replace a module that isPrime calls, and isPrime calls nothing.)

Testing the lower module first and using drivers in place of the higher modules that are not written yet is bottom-up integration. When Report is written, it replaces the driver and the two are tested together.