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 62 / 93
tests.jschange 2/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);
    assertEqual(Life.getCell(grid, 3, 0, true), 1, 'row 3 wraps to row 0');
    Life.setCell(grid, 2, 0, 1);
    assertEqual(Life.getCell(grid, -1, 0, true), 1, 'row -1 wraps to last row (2)');
    assertEqual(Life.getCell(grid, 0, -1, true), 0, 'col -1 wraps to last col (2), which is dead');
    Life.setCell(grid, 2, 2, 1);
−    assertEqual(Life.getCell(grid, -1, -1, true), 1, 'both axes wrap simultaneously');
    assertEqual(Life.getCell(grid, -1, -1, true), 1, 'both axes wrap simultaneously (-1 -> 2 on each)');
  });
 
  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);
 
322 linesjs
Edits …/tests.js
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