jsbeeb 1.1.1

package/tests/suite/cbm-hackers-post.md

@@ -0,0 +1,78 @@
+## Wolfgang Lorenz's 6502 test suite
+
+When Wolfgang Lorenz's excellent 6502 (well, actually there's some 6526
+stuff in there as well) test suite was mentioned earlier on, I recalled
+having re-packaged it a few years ago in a form more suitable for play
+on non-Commodore platforms (it was originally provided as a D64 image).
+
+In case anyone would find it useful I packed it up and put it online at
+http://jegt.net/~palm/testsuite-2.15.tar.gz
+
+Since it makes a few assumtions about the surrounding environment, I'd
+also like to share a few notes on the "test bench" environment I hacked
+up to be able to run it outside a C64:
+
+The testcase is started by loading " start" and starting the CPU.
+
+The load routine does the following:
+
+Check the filename for "trap17" and exit if it is, since this is where testing of non-6510 stuff begins.
+
+Read the starting address from the two first bytes of the file (LO, HI). Load the rest of the file into memory at the specified starting address.
+
+Initialize some memory locations:
+
+    $0002 = $00
+    $A002 = $00
+    $A003 = $80
+    $FFFE = $48
+    $FFFF = $FF
+    $01FE = $FF
+    $01FF = $7F
+
+Set up the KERNAL "IRQ handler" at $FF48:
+
+    FF48  48        PHA
+    FF49  8A        TXA
+    FF4A  48        PHA
+    FF4B  98        TYA
+    FF4C  48        PHA
+    FF4D  BA        TSX
+    FF4E  BD 04 01  LDA    $0104,X
+    FF51  29 10     AND    #$10
+    FF53  F0 03     BEQ    $FF58
+    FF55  6C 16 03  JMP    ($0316)
+    FF58  6C 14 03  JMP    ($0314)
+
+Set `S` to `$FD`, `P` to `$04` and `PC` to `$0801`
+
+Put trap instructions at `$FFD2`, `$E16F`, `$FFE4`, `$8000` and `$A474`, where the trap handler does the following:
+
+if `PC == $FFD2` (Print character):
+
+- Set `$030C = 0`
+- Print `PETSCII` character corresponding to value of `A`
+- Pop return address from stack
+- Set `PC` to return address
+- Re-start the CPU
+
+if `PC == $E16F` (Load):
+
+- `$BB` is `PETSCII` filename address, low byte
+- `$BC` is `PETSCII` filename address, high byte
+- `$B7` is `PETSCII` filename length
+- Load the file
+- Pop return address from stack
+- Set `PC` to `$0816`
+- Re-start the CPU
+
+if `PC == $FFE4` (Scan keyboard):
+
+- Set `A` to 3
+- Pop return address from stack
+- Set `PC` to return address
+- Re-start the CPU
+
+if `PC == $8000` or `PC == $A474`:
+
+- Exit

package/tests/test-machine.js

@@ -0,0 +1,288 @@
+import * as fdc from "../src/fdc.js";
+import { fake6502 } from "../src/fake6502.js";
+import { findModel } from "../src/models.js";
+import assert from "assert";
+import * as utils from "../src/utils.js";
+import * as Tokeniser from "../src/basic-tokenise.js";
+
+const MaxCyclesPerIter = 100 * 1000;
+
+export class TestMachine {
+    constructor(model, opts) {
+        model = model || "B-DFS1.2";
+        this.processor = fake6502(findModel(model), opts || {});
+    }
+
+    async initialise() {
+        await this.processor.initialise();
+    }
+
+    runFor(cycles) {
+        let left = cycles;
+        let stopped = false;
+        return new Promise((resolve) => {
+            const runAnIter = () => {
+                const todo = Math.max(0, Math.min(left, MaxCyclesPerIter));
+                if (todo) {
+                    stopped = !this.processor.execute(todo);
+                    left -= todo;
+                }
+                if (left && !stopped) {
+                    setTimeout(runAnIter, 0);
+                } else {
+                    resolve();
+                }
+            };
+            runAnIter();
+        });
+    }
+
+    async runUntilVblank() {
+        let hit = false;
+        if (this.processor.isMaster) throw new Error("Not yet implemented");
+        const hook = this.processor.debugInstruction.add((addr) => {
+            if (addr === 0xdd15) {
+                hit = true;
+                return true;
+            }
+        });
+        await this.runFor(10 * 1000 * 1000);
+        hook.remove();
+        assert(hit, "did not hit appropriate breakpoint in time");
+    }
+
+    async runUntilInput(secs) {
+        if (!secs) secs = 120;
+        console.log("Running until keyboard input requested");
+        const idleAddr = this.processor.model.isMaster ? 0xe7e6 : 0xe581;
+        let hit = false;
+        const hook = this.processor.debugInstruction.add((addr) => {
+            if (addr === idleAddr) {
+                hit = true;
+                return true;
+            }
+        });
+        await this.runFor(secs * 2 * 1000 * 1000);
+        hook.remove();
+        assert(hit, "did not hit appropriate breakpoint in time");
+        return this.runFor(10 * 1000);
+    }
+
+    async runUntilAddress(targetAddr, secs) {
+        if (!secs) secs = 120;
+        let hit = false;
+        const hook = this.processor.debugInstruction.add((addr) => {
+            if (addr === targetAddr) {
+                hit = true;
+                return true;
+            }
+        });
+        await this.runFor(secs * 2 * 1000 * 1000);
+        hook.remove();
+        assert(hit, "did not hit appropriate breakpoint in time");
+    }
+
+    async loadDisc(image) {
+        const data = await fdc.load(image);
+        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
+    }
+
+    async loadBasic(source) {
+        const tokeniser = await Tokeniser.create();
+        const tokenised = tokeniser.tokenise(source);
+        // TODO: dedupe from main.js
+        const page = this.readbyte(0x18) << 8;
+        for (let i = 0; i < tokenised.length; ++i) {
+            this.writebyte(page + i, tokenised.charCodeAt(i));
+        }
+        // Set VARTOP (0x12/3) and TOP(0x02/3)
+        const end = page + tokenised.length;
+        const endLow = end & 0xff;
+        const endHigh = (end >>> 8) & 0xff;
+        this.writebyte(0x02, endLow);
+        this.writebyte(0x03, endHigh);
+        this.writebyte(0x12, endLow);
+        this.writebyte(0x13, endHigh);
+    }
+
+    async type(text) {
+        console.log("Typing '" + text + "'");
+        const cycles = 40 * 1000;
+
+        const kd = (ch) => {
+            this.processor.sysvia.keyDown(ch);
+            return this.runFor(cycles).then(() => {
+                this.processor.sysvia.keyUp(ch);
+                return this.runFor(cycles);
+            });
+        };
+
+        const typeChar = (ch) => {
+            let shift = false;
+            switch (ch) {
+                case '"':
+                    ch = 50;
+                    shift = true;
+                    break;
+                case "*":
+                    ch = utils.keyCodes.APOSTROPHE;
+                    shift = true;
+                    break;
+                case "!":
+                    ch = utils.keyCodes.K1;
+                    shift = true;
+                    break;
+                case ".":
+                    ch = utils.keyCodes.PERIOD;
+                    break;
+                case ";":
+                    ch = utils.keyCodes.SEMICOLON;
+                    break;
+                case ":":
+                    ch = utils.keyCodes.APOSTROPHE;
+                    break;
+                case ",":
+                    ch = utils.keyCodes.COMMA;
+                    break;
+                case "&":
+                    ch = utils.keyCodes.K6;
+                    shift = true;
+                    break;
+                default:
+                    ch = ch.toUpperCase().charCodeAt(0);
+                    break;
+            }
+            if (shift) {
+                this.processor.sysvia.keyDown(16);
+                return this.runFor(cycles).then(() => {
+                    return kd(ch).then(() => {
+                        this.processor.sysvia.keyUp(16);
+                        return this.runFor(cycles);
+                    });
+                });
+            } else {
+                return kd(ch);
+            }
+        };
+
+        return text
+            .split("")
+            .reduce(function (p, char) {
+                return p.then(function () {
+                    return typeChar(char);
+                });
+            }, Promise.resolve())
+            .then(function () {
+                return kd(13);
+            });
+    }
+
+    writebyte(addr, val) {
+        this.processor.writemem(addr, val);
+    }
+
+    readbyte(addr) {
+        return this.processor.readmem(addr);
+    }
+
+    readword(addr) {
+        return this.readbyte(addr) | (this.readbyte(addr + 1) << 8);
+    }
+
+    captureText(onElement) {
+        const attributes = {
+            x: 0,
+            y: 0,
+            text: "",
+            foreground: 7,
+            background: 0,
+            mode: 7,
+        };
+        let currentText = "";
+        let params = [];
+        let nextN = 0;
+        let vduProc = null;
+
+        function flush() {
+            if (currentText.length) {
+                attributes.text = currentText;
+                onElement(attributes);
+                attributes.x += currentText.length; // Approximately...anyway
+            }
+            currentText = "";
+        }
+
+        function onChar(c) {
+            if (nextN) {
+                params.push(c);
+                if (--nextN === 0) {
+                    if (vduProc) vduProc(params);
+                    params = [];
+                    vduProc = null;
+                }
+                return;
+            }
+            switch (c) {
+                case 1: // Next char to printer
+                    nextN = 1;
+                    break;
+                case 10:
+                    attributes.y++;
+                    break;
+                case 12: // CLS
+                    attributes.x = 0;
+                    attributes.y = 0;
+                    break;
+                case 13:
+                    attributes.x = 0;
+                    break;
+                case 17: // Text colour
+                    nextN = 1;
+                    vduProc = function (params) {
+                        if (params[0] & 0x80) attributes.background = params[0] & 0xf;
+                        else attributes.foreground = params[0] & 0xf;
+                    };
+                    break;
+                case 18: // GCOL
+                    nextN = 2;
+                    break;
+                case 19: // logical colour
+                    nextN = 5;
+                    break;
+                case 22: // mode
+                    nextN = 1;
+                    vduProc = function (params) {
+                        attributes.mode = params[0];
+                        attributes.x = 0;
+                        attributes.y = 0;
+                    };
+                    break;
+                case 25: // plot
+                    nextN = 5;
+                    break;
+                case 28: // text window
+                    nextN = 4;
+                    break;
+                case 29: // origin
+                    nextN = 4;
+                    break;
+                case 31: // text location
+                    nextN = 2;
+                    vduProc = function (params) {
+                        attributes.x = params[0];
+                        attributes.y = params[1];
+                    };
+            }
+            if (c >= 32 && c < 0x7f) {
+                currentText += String.fromCharCode(c);
+            } else flush();
+            return false;
+        }
+
+        const wrchv = this.readword(0x20e);
+        this.processor.debugInstruction.add((addr) => {
+            if (addr === wrchv) onChar(this.processor.a);
+            return false;
+        });
+    }
+}

package/tests/test-suite.js

@@ -0,0 +1,147 @@
+"use strict";
+
+import * as utils from "../src/utils.js";
+import { fake6502 } from "../src/fake6502.js";
+
+const processor = fake6502();
+const IRQ_ROUTINE_START = 0xff48;
+const RTS_OPCODE = 0x60;
+const NOP_OPCODE = 0xea;
+
+// prettier-ignore
+const IRQ_ROUTINE = [
+    0x48, // PHA
+    0x8a, // TXA
+    0x48, // PHA
+    0x98, // TYA
+    0x48, // PHA
+    0xba, // TSX
+    0xbd, 0x04, 0x01, // LDA $0104,X
+    0x29, 0x10, // AND #$10
+    0xf0, 0x03, // BEQ $03
+    0x6c, 0x16, 0x03, // JMP ($0316)
+    0x6c, 0x14, 0x03 // JMP ($0314)
+];
+
+async function setup(filename) {
+    try {
+        initializeMemory();
+        await loadTest(filename);
+        setupIRQRoutine();
+        setupProcessor();
+    } catch (error) {
+        console.error(`Error in setup: ${error.message}`);
+    }
+}
+
+function initializeMemory() {
+    for (let i = 0x0000; i < 0xffff; ++i) processor.writemem(i, 0x00);
+}
+
+async function loadTest(filename) {
+    const data = await utils.loadData(`tests/suite/bin/${filename}`);
+    const addr = data[0] + (data[1] << 8);
+    console.log(`>> Loading test '${filename}' at ${utils.hexword(addr)}`);
+    for (let i = 2; i < data.length; ++i) processor.writemem(addr + i - 2, data[i]);
+}
+
+function setupIRQRoutine() {
+    for (let i = 0; i < IRQ_ROUTINE.length; ++i) processor.writemem(IRQ_ROUTINE_START + i, IRQ_ROUTINE[i]);
+}
+
+function setupProcessor() {
+    processor.writemem(0x0002, 0x00);
+    processor.writemem(0xa002, 0x00);
+    processor.writemem(0xa003, 0x80);
+    processor.writemem(0x01fe, 0xff);
+    processor.writemem(0x01ff, 0x7f);
+    processor.writemem(0xffd2, RTS_OPCODE);
+    processor.writemem(0x8000, RTS_OPCODE);
+    processor.writemem(0xa474, RTS_OPCODE);
+    processor.writemem(0xe16f, NOP_OPCODE);
+    processor.writemem(0xffe4, 0xa9);
+    processor.writemem(0xffe5, 0x03);
+    processor.writemem(0xffe6, RTS_OPCODE);
+    processor.writemem(0xfffe, 0x48);
+    processor.writemem(0xffff, 0xff);
+    processor.s = 0xfd;
+    processor.p.reset();
+    processor.p.i = true;
+    processor.pc = 0x0801;
+}
+
+let curLine = "";
+
+function petToAscii(char) {
+    if (char === 14 || char === 145) return "";
+    if (char === 147) return "\n-------\n";
+    if (char >= 0xc1 && char <= 0xda) return String.fromCharCode(char - 0xc1 + 65);
+    if (char >= 0x41 && char <= 0x5a) return String.fromCharCode(char - 0x41 + 97);
+    if (char < 32 || char >= 127) return ".";
+    return String.fromCharCode(char);
+}
+
+processor.debugInstruction.add((addr) => {
+    switch (addr) {
+        case 0xffd2:
+            handlePrint();
+            break;
+        case 0xe16f:
+            return handleLoad();
+        case 0x8000:
+        case 0xa474:
+            handleError();
+            break;
+        default:
+            break;
+    }
+    return false;
+});
+
+function handlePrint() {
+    if (processor.a === 13) {
+        console.log(curLine);
+        curLine = "";
+    } else {
+        curLine += petToAscii(processor.a);
+    }
+    processor.writemem(0x030c, 0x00);
+}
+
+function handleLoad() {
+    const filenameAddr = processor.readmem(0xbb) | (processor.readmem(0xbc) << 8);
+    const filenameLen = processor.readmem(0xb7);
+    let filename = "";
+    for (let i = 0; i < filenameLen; ++i) filename += petToAscii(processor.readmem(filenameAddr + i));
+    if (filename === "trap17") {
+        console.log("All tests complete");
+        process.exit(0);
+    }
+    setup(filename).then(anIter);
+    processor.pc--;
+    return true;
+}
+
+function handleError() {
+    if (curLine.length) console.log(curLine);
+    throw new Error("Test failed");
+}
+
+function anIter() {
+    for (;;) {
+        if (!processor.execute(10 * 1000 * 1000)) return;
+    }
+}
+
+async function main() {
+    try {
+        await processor.initialise();
+        const filename = process.argv.length === 3 ? process.argv[2] : " start";
+        await setup(filename);
+        anIter();
+    } catch (error) {
+        console.error(`Error in main: ${error.message}`);
+    }
+}
+
+main().then(() => {});

package/tests/test.css

@@ -0,0 +1,7 @@
+.success {
+  background-color: #062206;
+}
+
+.fail {
+  background-color: #440606;
+}