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

antigravitygemini · 28 steps · 1m 03s · 6 filessession 2a71ee07-8a5@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 14 / 28

tests.jschange 1/1

/**
 * PulseType Test Suite - Exercising WPM and Accuracy Math
 * Works both in Node.js (`node tests.js`) and in Browser (`tests.html`).
 */
 
// Import TypingMath if running in Node
let MathEngine;
if (typeof require !== 'undefined') {
    const appModule = require('./app.js');
    MathEngine = appModule.TypingMath;
} else if (typeof TypingMath !== 'undefined') {
    MathEngine = TypingMath;
}
 
const tests = [];
let passCount = 0;
let failCount = 0;
 
function test(name, fn) {
    tests.push({ name, fn });
}
 
function assertEqual(actual, expected, message) {
    if (actual !== expected) {
        throw new Error(`${message || 'Assertion failed'}: expected ${expected}, got ${actual}`);
    }
}
 
function assertAlmostEqual(actual, expected, precision = 2, message) {
    const diff = Math.abs(actual - expected);
    const tolerance = Math.pow(10, -precision);
    if (diff > tolerance) {
        throw new Error(`${message || 'Assertion failed'}: expected approx ${expected}, got ${actual}`);
    }
}
 
// ----------------------------------------------------
// TEST SUITE DEFINITIONS
// ----------------------------------------------------
 
test('calculateGrossWPM - Standard 60 second test', () => {
    // 300 characters in 60 seconds = 60 words / 1 minute = 60 WPM
    const result = MathEngine.calculateGrossWPM(300, 60);
    assertEqual(result, 60, '300 chars in 60s should be 60 Gross WPM');
});
 
test('calculateGrossWPM - Partial minute test (30s)', () => {
    // 150 characters in 30 seconds = 30 words / 0.5 minutes = 60 WPM
    const result = MathEngine.calculateGrossWPM(150, 30);
    assertEqual(result, 60, '150 chars in 30s should be 60 Gross WPM');
});
 
test('calculateGrossWPM - Zero characters', () => {
    const result = MathEngine.calculateGrossWPM(0, 60);
    assertEqual(result, 0, '0 chars in 60s should be 0 WPM');
});
 
test('calculateGrossWPM - Edge case zero/negative time', () => {
    assertEqual(MathEngine.calculateGrossWPM(100, 0), 0, 'Zero time should return 0 WPM');
    assertEqual(MathEngine.calculateGrossWPM(100, -10), 0, 'Negative time should return 0 WPM');
});
 
test('calculateNetWPM - Standard test with correct characters', () => {
    // 250 correct characters in 60 seconds = 50 Net WPM
    const result = MathEngine.calculateNetWPM(250, 60);
    assertEqual(result, 50, '250 correct chars in 60s should be 50 Net WPM');
});
 
test('calculateNetWPM - Fast typing 15 seconds', () => {
    // 100 correct characters in 15 seconds = 20 words / 0.25 min = 80 Net WPM
    const result = MathEngine.calculateNetWPM(100, 15);
    assertEqual(result, 80, '100 correct chars in 15s should be 80 Net WPM');
});
 
test('calculateNetWPM - Zero correct characters', () => {
    const result = MathEngine.calculateNetWPM(0, 60);
    assertEqual(result, 0, '0 correct chars should yield 0 Net WPM');
});
 
test('calculateAccuracy - 100% accuracy', () => {
    const result = MathEngine.calculateAccuracy(250, 250);
    assertEqual(result, 100, '250 correct out of 250 should be 100%');
});
 
test('calculateAccuracy - Partial accuracy', () => {
    // 200 correct out of 250 total = 80%
    const result = MathEngine.calculateAccuracy(200, 250);
    assertEqual(result, 80, '200 correct out of 250 should be 80%');
});
 
test('calculateAccuracy - Decimal accuracy rounding', () => {
    // 195 correct out of 200 total = 97.5%
    const result = MathEngine.calculateAccuracy(195, 200);
    assertEqual(result, 97.5, '195 correct out of 200 should be 97.5%');
});
 
test('calculateAccuracy - Zero total typed characters', () => {
    const result = MathEngine.calculateAccuracy(0, 0);
    assertEqual(result, 100, '0 typed chars should default to 100% accuracy');
});
 
test('calculateAccuracy - Zero correct out of positive total', () => {
    const result = MathEngine.calculateAccuracy(0, 50);
    assertEqual(result, 0, '0 correct out of 50 total should be 0%');
});
 
test('calculateErrors - Uncorrected error calculation', () => {
    assertEqual(MathEngine.calculateErrors(250, 200), 50, '250 total - 200 correct = 50 errors');
    assertEqual(MathEngine.calculateErrors(100, 100), 0, '100 total - 100 correct = 0 errors');
    assertEqual(MathEngine.calculateErrors(0, 0), 0, '0 total - 0 correct = 0 errors');
});
 
test('formatTime - Formatting seconds into MM:SS', () => {
    assertEqual(MathEngine.formatTime(60), '01:00');
    assertEqual(MathEngine.formatTime(0), '00:00');
    assertEqual(MathEngine.formatTime(125), '02:05');
    assertEqual(MathEngine.formatTime(9), '00:09');
});
 
// ----------------------------------------------------
// RUNNER FUNCTION
// ----------------------------------------------------
 
function runTests() {
    passCount = 0;
    failCount = 0;
    const results = [];
 
    console.log('----------------------------------------------------');
    console.log('Running PulseType Math Unit Tests...');
    console.log('----------------------------------------------------');
 
    for (const t of tests) {
        try {
            t.fn();
            passCount++;
            results.push({ name: t.name, status: 'PASS' });
            console.log(`[PASS] ${t.name}`);
        } catch (err) {
            failCount++;
            results.push({ name: t.name, status: 'FAIL', error: err.message });
            console.error(`[FAIL] ${t.name}\n       Reason: ${err.message}`);
        }
    }
 
    console.log('----------------------------------------------------');
    console.log(`Total: ${tests.length} | Passed: ${passCount} | Failed: ${failCount}`);
    console.log('----------------------------------------------------');
 
    return { total: tests.length, passed: passCount, failed: failCount, results };
}
 
// Auto-run if executed in Node.js
if (typeof process !== 'undefined' && process.argv) {
    const summary = runTests();
    if (summary.failed > 0) {
        process.exit(1);
    } else {
        process.exit(0);
    }
}
 

162 linesjs

Writes …/tests.html

Files at this step

drag the rail to scrub

Discussion

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

#antigravity #css #gemini #graphics #html #javascript #performance #quick #testing #ui

c5-agy

← all sessions