15. Testing your code

“It worked when I tried it”

Back in chapter 2 you wrote max. You probably ran it on one array, saw the right number, and moved on. Now suppose that next month you change max to make it faster. Is it still right? To find out, you would have to remember which arrays you tried, and what the answers should be.

Nobody remembers. So write it down, as code.

A test is code that checks code

The smallest possible check is an if:

if (max([3, 7, 2]) !== 7) {
  console.log('FAIL: max([3, 7, 2])');
}

That gets repetitive fast, so give the two jobs names. An assertion checks one fact and throws if it’s false. A test runs some assertions and reports whether anything threw:

function expectBe(got, want) {
  if (got !== want) {
    throw new Error(
      `expected ${want}, got ${got}`);
  }
}

function test(name, fn) {
  try {
    fn();
    console.log('pass: ' + name);
  } catch (e) {
    console.log('FAIL: ' + name);
    console.log('  ' + e.message);
  }
}

test('picks the largest', () => {
  expectBe(max([3, 7, 2]), 7);
});

That is nearly the whole idea, and it’s how the tests behind every exercise in this book work: test runs your function, expect(x).toBe(7) throws if x isn’t 7, and the runner counts what threw. Node’s built-in test runner uses the same rule: a test fails if it throws, and passes otherwise^[1].

function expectBe(got, want) {
  if (got !== want) {
    throw new Error(
      `expected ${want}, got ${got}`);
  }
}

function test(name, fn) {
  try {
    fn();
    console.log('pass: ' + name);
  } catch (e) {
    console.log('FAIL: ' + name);
    console.log('  ' + e.message);
  }
}

function double(n) {
  return n + n;
}

test('double 3', () => {
  expectBe(double(3), 6);
});
test('double 0', () => {
  expectBe(double(0), 1);
});
// The second test is wrong on purpose.
// Fix the test, not the function.

Which kind of equal?

Chapter 4 showed that === on objects asks “same object?”. So expect([1, 2]).toBe([1, 2]) fails: two separate arrays are never ===. When you want “same contents”, use toEqual, which compares the insides piece by piece.

Decimals need a third kind. 0.1 + 0.2 is not exactly 0.3 in JavaScript (try it: you get 0.30000000000000004; the next chapter shows why). So for computed decimals, use toBeCloseTo(0.3), which allows a tiny difference.

Edge cases

Here is a max that passes the obvious tests. Step through a test run and watch where it breaks:

function max(xs) {
  let best = 0;
  for (const x of xs) {
    if (x > best) best = x;
  }
  return best;
}

The bug survived three tests because they were all ordinary inputs. Bugs live at the edges: the empty list, the single item, the negative number.

Two programs that should agree

Every test so far needed you to know the right answer. What if you don’t? What is the max of a random 500-number list? Working it out by hand is the very thing you can’t do.

So write a second version that is slow but obviously correct. A value is the max if nothing in the list beats it:

function maxSlow(xs) {
  for (const x of xs) {
    let beaten = false;
    for (const y of xs) {
      if (y > x) beaten = true;
    }
    if (!beaten) return x;
  }
  return -Infinity;
}

Then feed both versions thousands of random lists, and stop at the first disagreement. Run this against the buggy max from above:

function max(xs) {
  let best = 0;
  for (const x of xs) {
    if (x > best) best = x;
  }
  return best;
}

function maxSlow(xs) {
  for (const x of xs) {
    let beaten = false;
    for (const y of xs) {
      if (y > x) beaten = true;
    }
    if (!beaten) return x;
  }
  return -Infinity;
}

// rand(k): a random whole number
// from 0 to k - 1
function rand(k) {
  return Math.floor(Math.random() * k);
}
function randomList() {
  const xs = [];
  const n = rand(5);
  for (let i = 0; i < n; i++) {
    xs.push(rand(19) - 9);
  }
  return xs;
}

let t = 0;
while (t < 1000) {
  const xs = randomList();
  const a = max(xs);
  const b = maxSlow(xs);
  if (a !== b) {
    console.log('disagree on', xs);
    console.log('max', a, 'slow', b);
    break;
  }
  t++;
}
console.log(`${t} lists agreed`);
// Fix max, then run it again.

Running tests outside the book

In your own projects, you don’t write test yourself. Node comes with one, and you run every test file with node --test^[1]:

import test from 'node:test';
import assert from 'node:assert';

test('max picks the largest', () => {
  assert.strictEqual(max([3, 7, 2]), 7);
});

assert.strictEqual is Node’s toBe^[2]. The engine code in this book’s repository uses a popular library called Vitest instead, whose expect(x).toBe(y) reads just like the one you’ve been using.

Your turn

function findMismatch(f, g, inputs) {
  // your code here
}

const abs1 = (n) => Math.abs(n);
const abs2 = (n) => n; // forgot < 0
console.log(
  findMismatch(abs1, abs2, [3, 0, -2]));

function check(got, want) {
  // your code here
}

console.log(check(1 + 1, 2));
check(1, 2); // should throw

What you learned

• A test runs code on chosen inputs and checks the results. Tests run every time, so they catch what memory forgets.
• An assertion checks one fact and throws if it’s false. toBe is ===, toEqual compares contents, toBeCloseTo allows tiny decimal differences.
• Edge cases (empty, one, zero, negative, huge, duplicates) are where bugs hide. Keep every old test.
• Differential testing checks that two implementations agree on many inputs, with no expected answers needed. It is how you’ll test the interpreters and compilers in this book.