Build a typing-speed test as a static web app in this directory: index.html, style.css,…

claude-codeclaude-fable-5 · 72 steps · 13m 06s · 7 filessession f0c9efc1-4df@agentsage-runs

Build a typing-speed test as a static web app in this directory: index.html, style.css, app.js, words.js. Random word streams, live WPM and accuracy, a 60-second timed mode and a zen mode, per-key error highlighting, results screen with WPM history chart on a canvas, high scores in localStorage, dark theme, and tests.html + tests.js exercising the WPM/accuracy math. Run the tests headless with node and fix what fails.

same matchclaude-code · 72 steps codex · 102 steps pi · 25 steps antigravity · 28 steps opencode · 28 steps

compare in arena

step 17 / 72

tests.jschange 1/2

/* Tests for the WPM/accuracy math and word generation.
   Run headless:  node tests.js
   Or in a browser via tests.html. */
 
(function () {
  'use strict';
 
  const isNode = typeof window === 'undefined';
  const api = isNode
    ? Object.assign({}, require('./words.js'), require('./app.js'))
    : window;
 
  const results = [];
 
  function test(name, fn) {
    try {
      fn();
      results.push({ name: name, pass: true });
    } catch (e) {
      results.push({ name: name, pass: false, error: e.message });
    }
  }
 
  function assert(cond, msg) {
    if (!cond) throw new Error(msg || 'assertion failed');
  }
 
  function assertEqual(actual, expected, msg) {
    if (actual !== expected) {
      throw new Error((msg ? msg + ': ' : '') + 'expected ' + expected + ', got ' + actual);
    }
  }
 
  function assertClose(actual, expected, eps) {
    eps = eps === undefined ? 1e-9 : eps;
    if (Math.abs(actual - expected) > eps) {
      throw new Error('expected ~' + expected + ', got ' + actual);
    }
  }
 
  /* ---------------- computeWPM ---------------- */
 
  test('computeWPM: 300 correct chars in 60s is 60 wpm', () => {
    assertClose(api.computeWPM(300, 60000), 60);
  });
 
  test('computeWPM: 25 correct chars in 30s is 10 wpm', () => {
    assertClose(api.computeWPM(25, 30000), 10);
  });
 
  test('computeWPM: 12 correct chars in 12s is 12 wpm', () => {
    assertClose(api.computeWPM(12, 12000), 12);
  });
 
  test('computeWPM: zero elapsed time returns 0', () => {
    assertEqual(api.computeWPM(100, 0), 0);
  });
 
  test('computeWPM: negative elapsed time returns 0', () => {
    assertEqual(api.computeWPM(100, -5000), 0);
  });
 
  test('computeWPM: zero chars is 0 wpm', () => {
    assertClose(api.computeWPM(0, 30000), 0);
  });
 
  /* ---------------- computeRawWPM ---------------- */
 
  test('computeRawWPM: 400 typed chars in 60s is 80 raw wpm', () => {
    assertClose(api.computeRawWPM(400, 60000), 80);
  });
 
  test('computeRawWPM: zero elapsed time returns 0', () => {
    assertEqual(api.computeRawWPM(200, 0), 0);
  });
 
  test('computeRawWPM is never below computeWPM for the same run', () => {
    const raw = api.computeRawWPM(320, 45000);
    const net = api.computeWPM(300, 45000);
    assert(raw >= net, 'raw ' + raw + ' < net ' + net);
  });
 
  /* ---------------- computeAccuracy ---------------- */
 
  test('computeAccuracy: 90 of 100 keystrokes is 90%', () => {
    assertClose(api.computeAccuracy(90, 100), 90);
  });
 
  test('computeAccuracy: 47 of 50 keystrokes is 94%', () => {
    assertClose(api.computeAccuracy(47, 50), 94);
  });
 
  test('computeAccuracy: no keystrokes yet reads 100%', () => {
    assertEqual(api.computeAccuracy(0, 0), 100);
  });
 
  test('computeAccuracy: every keystroke wrong is 0%', () => {
    assertClose(api.computeAccuracy(0, 25), 0);
  });
 
  test('computeAccuracy: perfect run is 100%', () => {
    assertClose(api.computeAccuracy(200, 200), 100);
  });
 
  test('computeAccuracy clamps corrupt counts into 0..100', () => {
    assertClose(api.computeAccuracy(120, 100), 100);
    assertClose(api.computeAccuracy(-5, 100), 0);
  });
 
  /* ---------------- countCorrectChars ---------------- */
 
  test('countCorrectChars: fully correct words count letters plus committed spaces', () => {
    // 'the' (3) + its space (1) + 'quick' (5); 'quick' is still in progress
    assertEqual(api.countCorrectChars(['the', 'quick'], ['the', 'quick']), 9);
  });
 
  test('countCorrectChars: a wrong letter only loses that letter', () => {
    assertEqual(api.countCorrectChars(['cat'], ['car']), 2);
  });
 
  test('countCorrectChars: extra letters earn nothing but cost nothing', () => {
    assertEqual(api.countCorrectChars(['cat'], ['cats']), 3);
  });
 
  test('countCorrectChars: a flawed committed word gets no space credit', () => {
    // 'ca' matches 2 letters of 'cat' but is not the full word -> no space
    assertEqual(api.countCorrectChars(['cat', 'dog'], ['ca', 'd']), 3);
  });
 
  test('countCorrectChars: empty typing counts nothing', () => {
    assertEqual(api.countCorrectChars(['cat', 'dog'], ['']), 0);
  });
 
  test('countCorrectChars: misplaced letters do not count', () => {
    // 'tac' vs 'cat': only the middle 'a' lines up
    assertEqual(api.countCorrectChars(['cat'], ['tac']), 1);
  });
 
  /* ---------------- countTypedChars ---------------- */
 
  test('countTypedChars: letters plus one space per committed word', () => {
    // 'the' (3) + space (1) + 'qui' (3)
    assertEqual(api.countTypedChars(['the', 'qui']), 7);
  });
 
  test('countTypedChars: a single in-progress word has no space', () => {
    assertEqual(api.countTypedChars(['abc']), 3);
  });
 
  test('countTypedChars: nothing typed is zero', () => {
    assertEqual(api.countTypedChars(['']), 0);
  });
 
  /* ---------------- an end-to-end scoring scenario ---------------- */
 
  test('scenario: typed run produces consistent wpm/raw/accuracy', () => {
    const targets = ['the', 'quick', 'brown', 'fox'];
    // Typed 'the ', 'quick ', 'brwn ' (one wrong word), then 'fox' in progress.
    const typed = ['the', 'quick', 'brwn', 'fox'];
    const correct = api.countCorrectChars(targets, typed);
    // the(3)+space + quick(5)+space + brwn: b,r match then w vs o, n vs w -> 2 + fox(3)
    assertEqual(correct, 15);
    const typedChars = api.countTypedChars(typed);
    assertEqual(typedChars, 17); // 3+5+4+3 letters + 3 spaces? -> 15 letters + 3 spaces
    const elapsedMs = 15000;
    assertClose(api.computeWPM(correct, elapsedMs), (15 / 5) * 4); // 12 wpm
    assert(api.computeRawWPM(typedChars, elapsedMs) >= api.computeWPM(correct, elapsedMs));
  });
 
  /* ---------------- word generation ---------------- */
 
  test('generateWords: returns the requested count', () => {
    assertEqual(api.generateWords(50).length, 50);
  });
 
  test('generateWords: only uses words from the list', () => {
    const set = new Set(api.WORDS);
    assert(api.generateWords(100).every((w) => set.has(w)), 'unknown word in stream');
  });
 
  test('generateWords: honors an injected rng', () => {
    const stream = api.generateWords(5, () => 0);
    assert(stream.every((w) => w === api.WORDS[0]), 'rng=0 should always pick the first word');
  });
 
  test('generateWords: rng just below 1 picks the last word', () => {
    const stream = api.generateWords(3, () => 0.9999999);
    assert(
      stream.every((w) => w === api.WORDS[api.WORDS.length - 1]),
      'rng~1 should pick the last word'
    );
  });
 
  test('WORDS: pool is non-trivial and lowercase alphabetic', () => {
    assert(api.WORDS.length >= 100, 'need a reasonable pool');
    assert(api.WORDS.every((w) => /^[a-z]+$/.test(w)), 'words must be lowercase a-z');
  });
 
  /* ---------------- report ---------------- */
 
  const failed = results.filter((r) => !r.pass);
 
  if (isNode) {
    for (const r of results) {
      console.log((r.pass ? 'PASS' : 'FAIL') + '  ' + r.name + (r.pass ? '' : ' — ' + r.error));
    }
    console.log('\n' + (results.length - failed.length) + '/' + results.length + ' tests passed');
    process.exit(failed.length ? 1 : 0);
  } else {
    const list = document.getElementById('results');
    const summary = document.getElementById('summary');
    for (const r of results) {
      const li = document.createElement('li');
      li.className = r.pass ? 'pass' : 'fail';
      li.textContent = (r.pass ? 'PASS' : 'FAIL') + '  ' + r.name + (r.pass ? '' : ' — ' + r.error);
      list.appendChild(li);
    }
    summary.textContent = (results.length - failed.length) + '/' + results.length + ' tests passed';
    summary.className = failed.length ? 'fail' : 'pass';
  }
})();
 

222 linesjs

Writes …/tests.js

Files at this step

drag the rail to scrub

Discussion

No comments yet. Start the discussion. Recorded by @agentsage-runs.

#claude #claude-code #claude-fable-5 #css #graphics #html #javascript #medium #performance #skills #subagents #testing

c1-claude

← all sessions