Build a Conway's Game of Life explorer as a static page in this directory: index.html, …

claude-codeclaude-sonnet-5 · 93 steps · 12m 25s · 6 filessession b799a226-866@patrick-toulme
Build a Conway's Game of Life explorer as a static page in this directory: index.html, style.css, life.js. Canvas grid with play/pause/step/clear, speed slider, drag-to-draw cells, a library of classic patterns (glider, glider gun, pulsar) placeable by click, wrap-around edges toggle, generation counter, dark theme, and tests.html + tests.js exercising the next-generation rules. Run the tests headless with node and fix what fails.
same matchclaude-code · 106 steps claude-code · 93 steps claude-code · 29 steps claude-code · 95 steps
compare in arena
step 11 / 93
tests.jschange 1/4
/**
 * Test suite for life.js core rules.
 *
 * Runs headless under Node:   node tests.js
 * Also runnable in a browser: tests.html loads life.js then this file and
 * renders results into the page instead of (or alongside) the console.
 */
(function (global) {
  'use strict';
 
  const Life = (typeof module !== 'undefined' && module.exports)
    ? require('./life.js')
    : global.Life;
 
  const results = [];
 
  function test(name, fn) {
    try {
      fn();
      results.push({ name: name, pass: true });
    } catch (err) {
      results.push({ name: name, pass: false, error: err.message });
    }
  }
 
  function assert(condition, message) {
    if (!condition) {
      throw new Error(message || 'assertion failed');
    }
  }
 
  function assertEqual(actual, expected, message) {
    const a = JSON.stringify(actual);
    const e = JSON.stringify(expected);
    if (a !== e) {
      throw new Error((message ? message + ' — ' : '') + 'expected ' + e + ' but got ' + a);
    }
  }
 
  function gridFromRows(rows) {
    return rows.map(function (row) { return row.slice(); });
  }
 
  function liveCoords(grid) {
    const coords = [];
    for (let r = 0; r < grid.length; r++) {
      for (let c = 0; c < grid[r].length; c++) {
        if (grid[r][c]) coords.push([r, c]);
      }
    }
    return coords;
  }
 
  // -----------------------------------------------------------------------
  // Grid basics
  // -----------------------------------------------------------------------
 
  test('createGrid builds the requested dimensions, all dead', function () {
    const grid = Life.createGrid(3, 5);
    assertEqual(Life.getRows(grid), 3);
    assertEqual(Life.getCols(grid), 5);
    assertEqual(Life.countLiveCells(grid), 0);
  });
 
  test('setCell/getCell round-trip', function () {
    const grid = Life.createGrid(4, 4);
    Life.setCell(grid, 1, 2, 1);
    assertEqual(Life.getCell(grid, 1, 2, false), 1);
    assertEqual(Life.getCell(grid, 2, 1, false), 0);
  });
 
  test('getCell returns 0 out of bounds when not wrapping', function () {
    const grid = Life.createGrid(3, 3);
    assertEqual(Life.getCell(grid, -1, 0, false), 0);
    assertEqual(Life.getCell(grid, 0, 3, false), 0);
    assertEqual(Life.getCell(grid, 3, 3, false), 0);
  });
 
  test('getCell wraps around edges when wrapping is enabled', function () {
    const grid = Life.createGrid(3, 3);
    Life.setCell(grid, 0, 0, 1);
    assertEqual(Life.getCell(grid, 3, 0, true), 1, 'row wraps to 0');
    assertEqual(Life.getCell(grid, -1, 0, true), 1, 'negative row wraps to last row');
    assertEqual(Life.getCell(grid, 0, -1, true), 0);
    Life.setCell(grid, 2, 2, 1);
    assertEqual(Life.getCell(grid, -1, -1, true), 1, 'both axes wrap simultaneously');
  });
 
  test('countLiveCells sums all live cells', function () {
    const grid = gridFromRows([
      [1, 0, 1],
      [0, 1, 0],
      [0, 0, 0]
    ]);
    assertEqual(Life.countLiveCells(grid), 3);
  });
 
  // -----------------------------------------------------------------------
  // Neighbor counting
  // -----------------------------------------------------------------------
 
  test('countLiveNeighbors counts all 8 surrounding cells', function () {
    const grid = gridFromRows([
      [1, 1, 1],
      [1, 0, 1],
      [1, 1, 1]
    ]);
    assertEqual(Life.countLiveNeighbors(grid, 1, 1, false), 8);
  });
 
  test('countLiveNeighbors ignores off-grid neighbors without wrap', function () {
    const grid = gridFromRows([
      [1, 1, 0],
      [1, 0, 0],
      [0, 0, 0]
    ]);
    // Corner cell (0,0) only has 3 in-bounds neighbors, all live.
    assertEqual(Life.countLiveNeighbors(grid, 0, 0, false), 3);
  });
 
  test('countLiveNeighbors counts wrapped neighbors across edges', function () {
    const grid = Life.createGrid(3, 3);
    Life.setCell(grid, 2, 2, 1); // diagonal wrap-neighbor of (0,0)
    Life.setCell(grid, 2, 0, 1); // vertical wrap-neighbor of (0,0)
    Life.setCell(grid, 0, 2, 1); // horizontal wrap-neighbor of (0,0)
    assertEqual(Life.countLiveNeighbors(grid, 0, 0, true), 3);
    assertEqual(Life.countLiveNeighbors(grid, 0, 0, false), 0);
  });
 
  // -----------------------------------------------------------------------
  // Rule-of-life behavior via nextGeneration
  // -----------------------------------------------------------------------
 
  test('underpopulation: a live cell with fewer than 2 neighbors dies', function () {
    const grid = gridFromRows([
      [0, 0, 0],
      [0, 1, 0],
      [0, 0, 1]
    ]);
    const next = Life.nextGeneration(grid, false);
    assertEqual(next[1][1], 0, 'lone live cell should die from isolation');
  });
 
  test('overpopulation: a live cell with more than 3 neighbors dies', function () {
    const grid = gridFromRows([
      [1, 1, 1],
      [1, 1, 1],
      [0, 0, 0]
    ]);
    const next = Life.nextGeneration(grid, false);
    assertEqual(next[0][1], 0, 'center-top cell has 5 live neighbors, dies');
    assertEqual(next[1][1], 0, 'center cell has 5 live neighbors, dies');
  });
 
  test('survival: a live cell with 2 or 3 neighbors survives', function () {
    const grid = gridFromRows([
      [1, 1, 0],
      [1, 0, 0],
      [0, 0, 0]
    ]);
    const next = Life.nextGeneration(grid, false);
    assertEqual(next[0][0], 1, 'top-left has exactly 2 live neighbors, survives');
  });
 
  test('reproduction: a dead cell with exactly 3 neighbors becomes alive', function () {
    const grid = gridFromRows([
      [1, 1, 0],
      [1, 0, 0],
      [0, 0, 0]
    ]);
    const next = Life.nextGeneration(grid, false);
    assertEqual(next[1][1], 1, 'center cell has exactly 3 live neighbors, is born');
  });
 
  test('dead cell with other than 3 neighbors stays dead', function () {
    const grid = gridFromRows([
      [1, 1, 0],
      [0, 0, 0],
      [0, 0, 0]
    ]);
    const next = Life.nextGeneration(grid, false);
    assertEqual(next[1][1], 0, 'only 2 live neighbors, stays dead');
  });
 
  // -----------------------------------------------------------------------
  // Still lifes and oscillators
  // -----------------------------------------------------------------------
 
  test('block still life is stable across generations', function () {
    const grid = Life.placePattern(Life.createGrid(6, 6), Life.PATTERNS.block, 2, 2);
    const next = Life.nextGeneration(grid, false);
    assertEqual(next, grid, 'block should be unchanged');
  });
 
  test('blinker oscillates with period 2', function () {
    let grid = Life.placePattern(Life.createGrid(5, 5), Life.PATTERNS.blinker, 2, 1);
    const gen1 = Life.nextGeneration(grid, false);
    const gen2 = Life.nextGeneration(gen1, false);
    assert(JSON.stringify(gen1) !== JSON.stringify(grid), 'blinker should change shape after 1 generation');
    assertEqual(gen2, grid, 'blinker should return to its original shape after 2 generations');
    assertEqual(Life.countLiveCells(gen1), 3);
  });
 
  test('toad oscillates with period 2', function () {
    let grid = Life.placePattern(Life.createGrid(6, 6), Life.PATTERNS.toad, 2, 1);
    const gen1 = Life.nextGeneration(grid, false);
    const gen2 = Life.nextGeneration(gen1, false);
    assert(JSON.stringify(gen1) !== JSON.stringify(grid), 'toad should change shape after 1 generation');
    assertEqual(gen2, grid, 'toad should return to its original shape after 2 generations');
  });
 
  test('glider translates diagonally by (1,1) every 4 generations', function () {
    let grid = Life.placePattern(Life.createGrid(12, 12), Life.PATTERNS.glider, 1, 1);
    let next = grid;
    for (let i = 0; i < 4; i++) {
      next = Life.nextGeneration(next, false);
    }
    const originalCoords = liveCoords(grid).map(function (c) { return [c[0] + 1, c[1] + 1]; }).sort();
    const shiftedCoords = liveCoords(next).sort();
    assertEqual(shiftedCoords, originalCoords, 'glider shape should reappear shifted by (1,1)');
  });
 
  // -----------------------------------------------------------------------
  // Pattern library sanity
  // -----------------------------------------------------------------------
 
  test('pattern library has the expected classic patterns', function () {
    assert(Life.PATTERNS.glider, 'glider pattern missing');
    assert(Life.PATTERNS.gliderGun, 'glider gun pattern missing');
    assert(Life.PATTERNS.pulsar, 'pulsar pattern missing');
  });
 
  test('glider pattern has 5 live cells', function () {
    assertEqual(Life.PATTERNS.glider.cells.length, 5);
  });
 
  test('pulsar pattern has 48 live cells and is stable-shaped after 3 generations', function () {
    assertEqual(Life.PATTERNS.pulsar.cells.length, 48);
    let grid = Life.placePattern(Life.createGrid(20, 20), Life.PATTERNS.pulsar, 3, 3);
    let next = grid;
    for (let i = 0; i < 3; i++) {
      next = Life.nextGeneration(next, false);
    }
    assertEqual(next, grid, 'pulsar has period 3 and should match its original shape');
  });
 
  test('Gosper glider gun pattern has 36 live cells', function () {
    assertEqual(Life.PATTERNS.gliderGun.cells.length, 36);
  });
 
  test('glider gun produces a new live glider-sized cluster after 30 generations', function () {
    let grid = Life.placePattern(Life.createGrid(60, 90), Life.PATTERNS.gliderGun, 2, 2);
    const before = Life.countLiveCells(grid);
    let next = grid;
    for (let i = 0; i < 30; i++) {
      next = Life.nextGeneration(next, false);
    }
    const after = Life.countLiveCells(next);
    assert(after > before, 'glider gun should have spawned extra live cells (gliders) by generation 30');
  });
 
  // -----------------------------------------------------------------------
  // placePattern
  // -----------------------------------------------------------------------
 
  test('placePattern stamps cells without clearing unrelated live cells', function () {
    let grid = Life.createGrid(6, 6);
    Life.setCell(grid, 5, 5, 1);
    grid = Life.placePattern(grid, Life.PATTERNS.block, 0, 0);
    assertEqual(Life.getCell(grid, 5, 5, false), 1, 'pre-existing live cell should survive placement');
    assertEqual(Life.countLiveCells(grid), Life.PATTERNS.block.cells.length + 1);
  });
 
  test('placePattern does not mutate the input grid', function () {
    const grid = Life.createGrid(6, 6);
    const before = JSON.stringify(grid);
    Life.placePattern(grid, Life.PATTERNS.glider, 0, 0);
    assertEqual(JSON.stringify(grid), before, 'original grid should be untouched');
  });
 
  // -----------------------------------------------------------------------
  // Reporting
  // -----------------------------------------------------------------------
 
  function report() {
    const failed = results.filter(function (r) { return !r.pass; });
 
    if (typeof document !== 'undefined') {
      const container = document.getElementById('results');
      if (container) {
        const summary = document.createElement('p');
        summary.className = 'summary ' + (failed.length ? 'summary-fail' : 'summary-pass');
        summary.textContent = (results.length - failed.length) + ' / ' + results.length + ' tests passed';
        container.appendChild(summary);
 
        const list = document.createElement('ul');
        results.forEach(function (r) {
          const item = document.createElement('li');
          item.className = r.pass ? 'pass' : 'fail';
          item.textContent = (r.pass ? 'PASS' : 'FAIL') + ' — ' + r.name + (r.error ? ' (' + r.error + ')' : '');
          list.appendChild(item);
        });
        container.appendChild(list);
      }
    }
 
    if (typeof console !== 'undefined') {
      results.forEach(function (r) {
        console.log((r.pass ? 'PASS' : 'FAIL') + ' - ' + r.name + (r.error ? ': ' + r.error : ''));
      });
      console.log(results.length - failed.length + '/' + results.length + ' tests passed');
    }
 
    if (typeof process !== 'undefined' && failed.length > 0) {
      process.exitCode = 1;
    }
  }
 
  report();
})(typeof window !== 'undefined' ? window : globalThis);
 
321 linesjs
Now let's run the tests headless with Node and fix any failures before building the rest of…
Files at this step
drag the rail to scrub
Discussion

No comments yet. Start the discussion. Recorded by @patrick-toulme.
#claude #claude-code #claude-sonnet-5 #css #game #graphics #html #javascript #medium #subagents
m2-sonnet5
← all sessions