jsbeeb 1.1.1 → 1.3.2

package/release-please-config.json

@@ -1,13 +0,0 @@
-{
-  "release-type": "node",
-  "packages": {
-    ".": {
-      "changelog-path": "CHANGELOG.md",
-      "release-type": "node",
-      "bump-minor-pre-major": true,
-      "bump-patch-for-minor-pre-major": true,
-      "draft": false,
-      "prerelease": false
-    }
-  }
-}

package/run-container.sh

@@ -1,92 +0,0 @@
-#!/usr/bin/env bash
-# Helper script that builds and launches the Docker container.
-
-# ---------------------------------------------------------------------
-
-function main
-{
-    # initialize
-    cd `dirname "$0"`
-    PORT=8271
-    IMAGE_TAG=latest
-    CONTAINER_NAME=jsbeeb
-    DETACH=
-    NO_BUILD=
-
-    # parse the command-line arguments
-    if [ $# -eq 0 ]; then
-        print_help
-        exit 0
-    fi
-    params="$(getopt -o p:t:d -l port:,tag:,name:,detach,,no-build,help --name "$0" -- "$@")"
-    if [ $? -ne 0 ]; then exit 1; fi
-    eval set -- "$params"
-    while true; do
-        case "$1" in
-            -p | --port)
-                PORT=$2
-                shift 2 ;;
-            -t | --tag)
-                IMAGE_TAG=$2
-                shift 2 ;;
-            --name)
-                CONTAINER_NAME=$2
-                shift 2 ;;
-            -d | --detach )
-                DETACH=--detach
-                shift 1 ;;
-            --no-build )
-                NO_BUILD=1
-                shift 1 ;;
-            --help )
-                print_help
-                exit 0 ;;
-            -- ) shift ; break ;;
-            * )
-                echo "Unknown option: $1" >&2
-                exit 1 ;;
-        esac
-    done
-
-    # build the image
-    if [ -z "$NO_BUILD" ]; then
-        echo Building the \"$IMAGE_TAG\" image...
-        docker build \
-            --tag jsbeeb:$IMAGE_TAG \
-            . 2>&1 \
-          | sed -e 's/^/  /'
-        if [ ${PIPESTATUS[0]} -ne 0 ]; then exit 10 ; fi
-        echo
-    fi
-
-    # launch the container
-    echo Launching the \"$IMAGE_TAG\" image as \"$CONTAINER_NAME\"...
-    docker run \
-        --name $CONTAINER_NAME \
-        --publish $PORT:80 \
-        $DETACH \
-        -it --rm \
-        jsbeeb:$IMAGE_TAG \
-        2>&1 \
-      | sed -e 's/^/  /'
-    exit ${PIPESTATUS[0]}
-}
-
-# ---------------------------------------------------------------------
-
-function print_help {
-    echo "`basename "$0"` {options}"
-    cat <<EOM
-  Build and launch the "jsbeeb" container.
-
-    -p  --port             Web server port number.
-    -t  --tag              Docker image tag.
-        --name             Docker container name.
-    -d  --detach           Detach from the container and let it run in the background.
-        --no-build         Launch the container as-is (i.e. without rebuilding the image first).
-EOM
-}
-
-# ---------------------------------------------------------------------
-
-main "$@"

package/tests/integration/RmwX.asm

@@ -1,47 +0,0 @@
-\ Timings test (thanks to Ed Spittles)
-\ build with: beebasm -i RmwX.asm -do ../discs/RmwX.ssd -boot Timings
-ORG &100
-.start
-NOP:NOP:NOP:NOP
-NOP:NOP:NOP:NOP
-NOP:NOP:NOP:NOP
-NOP:NOP:NOP:NOP
-.begin
-SEI
-LDA#&20:STA&FE44:STA&FE45
-LDX#0
-INC&41FF,X:INC&41FF,X
-LDA&FE44:STA&100
-DEC&41FF,X:DEC&41FF,X
-LDA&FE44:STA&101
-ROL&41FF,X:ROL&41FF,X
-LDA&FE44:STA&102
-ROR&41FF,X:ROR&41FF,X
-LDA&FE44:STA&103
-LSR&41FF,X:LSR&41FF,X
-LDA&FE44:STA&104
-ASL&41FF,X:ASL&41FF,X
-LDA&FE44:STA&105
-LDA#&20:STA&FE44:STA&FE45
-LDX#&FF
-INC&41FF,X:INC&41FF,X
-LDA&FE44:STA&108
-DEC&41FF,X:DEC&41FF,X
-LDA&FE44:STA&109
-ROL&41FF,X:ROL&41FF,X
-LDA&FE44:STA&10a
-ROR&41FF,X:ROR&41FF,X
-LDA&FE44:STA&10b
-INX
-INC&41FF,X:INC&41FF,X
-LDA&FE44:STA&10c
-DEC&41FF,X:DEC&41FF,X
-LDA&FE44:STA&10d
-ROL&41FF,X:ROL&41FF,X
-LDA&FE44:STA&10e
-ROR&41FF,X:ROR&41FF,X
-LDA&FE44:STA&10f
-CLI:RTS
-.end
-
-SAVE "Timings", start, end, begin

package/tests/integration/TestInstructionsSource

@@ -1,27 +0,0 @@
-REM TestInstructions
-HIMEM = &4000
-FOR N%=0 TO 2 STEP 2:P%=&4400:[OPT N%
-SEI
-LDA #0
-STA testInstr + 1
-.loop
-LDA #0
-TAX
-TAY
-CLC
-.testInstr ADC #0
-.storeAddr STA &4000
-INC testInstr + 1
-INC storeAddr + 1
-BNE loop
-CLI
-RTS
-]NEXT
-CALL &4400
-FOR N%=0 TO 255 STEP 16
-FOR M%=&4000 + N% TO &4000 + N% + 15
-IF ?M%<16:PRINT ;0;
-PRINT ;~?M%;
-NEXT
-PRINT
-NEXT

package/tests/integration/TestTimingsResults

@@ -1,27 +0,0 @@
->RUN
-4436 (AD 1 10)        0       DD
-4443 (AD 2 10)        0       DD
-4450 (AD 3 10)        0       DD
-445E (AD 4 10)        0       DD
-0 (C6 16 D0)          0       0
-0 (C6 16 D0)          0       0
-4488 (AD 7 10)        0       FF
-4497 (AD 8 10)        0       0
-0 (C6 16 D0)          0       0
-44B8 (E6 71 8C)       C0      FF
-44C5 (E6 71 8C)       C0      FF
-0 (C6 16 D0)          0       0
-0 (C6 16 D0)          0       0
-44F6 (AD E 10)        C0      DB
-4506 (AD F 10)        C0      DC
-4516 (AD 10 10)       C0      FF
-4527 (AD 11 10)       C0      0
-453A (8E 64 FE)       C0      1
-454A (8E 64 FE)       C0      1
-4559 (AD 14 20)       C0      0
-4569 (AD 15 20)       C0      0
-4578 (AD 16 20)       C0      1
-458A (E6 71 8C)       C0      FF
-4599 (E6 71 8C)       C0      0
-45A6 (E6 71 78)       C0      0
-0 (C6 16 D0)          0       0

package/tests/integration/TestTimingsSource

@@ -1,61 +0,0 @@
-    1 REM TestTimings - by Richard Talbot-Watkins
-    5 HIMEM=&4000
-   10 FOR N%=0 TO 2 STEP 2:P%=&4400:[OPT N%
-   20 SEI
-   30 LDA #irq MOD 256:STA &204
-   40 LDA #irq DIV 256:STA &205
-   50 LDA &FE4E:STA &70
-   60 LDA #&7F:STA &FE4E:STA &FE6E
-   70 LDA #&C0:STA &FE6E
-   80 LDA #0:STA &FE6B:STA &71
-   90 CLI
-  100 LDX #4:STX &FE64:LDY #0
-  105 STY &FE65:LDA (0),Y:LDA #1:DEC &FE65:LDA &1001:INC &71
-  110 STY &FE65:LDA (0,X):DEC &FE65:LDA &1002:INC &71
-  120 STY &FE65:LDA (0),Y:DEC &FE65:LDA &1003:INC &71
-  130 STY &FE65:LDA &1234:DEC &FE65:LDA &1004:INC &71
-  140 STY &FE65:LDA &12:DEC &FE65:LDA &1005:INC &71
-  150 STY &FE65:LDA #1:DEC &FE65:LDA &1006:INC &71
-  160 STY &FE65:LDA (0,X):LDA &1234:LDA &FE64:LDA &1007:INC &71
-  170 STY &FE65:LDA (0,X):LDA &12:LDA &FE64:LDA &1008:INC &71
-  180 STY &FE65:LDA (0,X):LDA #1:LDA &FE64:LDA &1009:INC &71
-  190 STY &FE65:LDA (0),Y:LDA #1:LDA &FE64:LDA &100A:INC &71
-  191 STY &FE65:LDA (0,X):LDA &FE64:LDA &100B:INC &71
-  192 STY &FE65:LDA (0),Y:LDA &1234:ROL &FE64:LDA &100C:STX &FE64:INC &71
-  193 STY &FE65:LDA (0),Y:LDA &12:ROL &FE64:LDA &100D:STX &FE64:INC &71
-  195 STY &FE65:LDA (0),Y:LDA #1:ROL &FE64:LDA &100E:STX &FE64:INC &71
-  200 STY &FE65:LDA (0,X):ROL &FE64:LDA &100F:STX &FE64:INC &71
-  210 STY &FE65:LDA (0),Y:ROL &FE64:LDA &1010:STX &FE64:INC &71
-  220 STY &FE65:LDA &1234:ROL &FE64:LDA &1011:STX &FE64:INC &71
-  230 STY &FE65:LDA &12:ROL &FE64:LDA &1012:STX &FE64:INC &71
-  240 STY &FE65:LDA #1:ROL &FE64:LDA &1013:STX &FE64:INC &71
-  241 STY &FE65:LDA (0,X):LDA (0),Y:LDA &1014:LDA &2014:INC &71
-  242 STY &FE65:LDA (0,X):LDA &1234:LDA &1015:LDA &2015:INC &71
-  243 STY &FE65:LDA (0,X):LDA &12:LDA &1016:LDA &2016:INC &71
-  244 STY &FE65:LDA (0,X):LDA #1:LDA &1017:LDA &2017:INC &71
-  245 STY &FE65:LDA (0),Y:LDA #1:LDA &1018:LDA &2018:INC &71
-  246 STY &FE65:LDA (0,X):LDA &1019:LDA &2019:INC &71
-  250 SEI
-  260 LDA &70:STA &FE4E:LDA #&7F:STA &FE6E
-  270 LDA #?&204:STA &204
-  280 LDA #?&205:STA &205
-  290 CLI:RTS
-  300 .irq
-  310 STX &72
-  320 TSX:INX:INX:LDA &100,X:STA &73
-  325 INX:LDA &100,X
-  330 LDX &71:STA &4300,X
-  335 LDA &73:STA &4000,X
-  340 LDA &FE6D:STA &4100,X
-  350 LDA &FE64:STA &4200,X
-  360 LDX &72
-  370 LDA &FC:RTI
-  380 ]NEXT
-  385 *FX 16,0
-  390 FOR N%=0 TO &3FF STEP 4:N%!&4000=0:NEXT
-  400 CALL &4400
-  410 FOR N%=0 TO ?&71
-  420 A%=(N%?&4300)*256+(N%?&4000)
-  430 PRINT ;~A%;" (";~A%?0;" ";~A%?1;" ";~A%?2;") ";TAB(22);~N%?&4100;TAB(30);~N%?&4200
-  440 NEXT
-  

package/tests/integration/bcd.js

@@ -1,23 +0,0 @@
-import { describe, it } from "vitest";
-import { TestMachine } from "../test-machine.js";
-import assert from "assert";
-
-describe("test binary coded decimal behaviour", { timeout: 30000 }, function () {
-    const doTest = async (model) => {
-        const testMachine = new TestMachine(model);
-        await testMachine.initialise();
-        await testMachine.loadDisc("discs/bcdtest.ssd");
-        await testMachine.runUntilInput();
-        await testMachine.type("*BCDTEST");
-        let output = "";
-        testMachine.captureText((elem) => (output += elem.text));
-        await testMachine.runUntilInput();
-        assert(output.indexOf("PASSED") >= 0, `Failed with ${output}`);
-    };
-    it("should match on 65C12", async () => {
-        await doTest("Master");
-    });
-    it("should match on 6502", async () => {
-        await doTest();
-    });
-});

package/tests/integration/dormann.js

@@ -1,101 +0,0 @@
-"use strict";
-
-import _ from "underscore";
-import { describe, it } from "vitest";
-import * as utils from "../../src/utils.js";
-import { fake6502, fake65C02, fake65C12 } from "../../src/fake6502.js";
-
-import assert from "assert";
-
-const log = false;
-
-async function runTest(processor, test, name) {
-    const base = "tests/6502_65C02_functional_tests/bin_files/" + test;
-
-    function parseSuccess(listing) {
-        let expectedPc = null;
-        let next = false;
-        let successRe = /^\s*success\b\s*(;.*)?$/;
-        _.each(listing.split("\n"), function (line) {
-            if (next) {
-                next = false;
-                expectedPc = parseInt(line.match(/^([0-9a-fA-F]+)/)[1], 16);
-                console.log("Found success address $" + utils.hexword(expectedPc));
-            } else {
-                next = !!line.match(successRe);
-            }
-        });
-        if (expectedPc === null) throw "Unable to parse";
-        return expectedPc;
-    }
-
-    const expectedPc = parseSuccess((await utils.loadData(base + ".lst")).toString());
-    const data = await utils.loadData(base + ".bin");
-    for (let i = 0; i < data.length; ++i) processor.writemem(i, data[i]);
-
-    processor.pc = 0x400;
-    processor.debugInstruction.add(function (addr) {
-        if (log) {
-            console.log(
-                utils.hexword(addr) +
-                    " : A=" +
-                    utils.hexbyte(processor.a) +
-                    " : X=" +
-                    utils.hexbyte(processor.x) +
-                    " : Y=" +
-                    utils.hexbyte(processor.y) +
-                    " : " +
-                    processor.disassembler.disassemble(processor.pc)[0],
-            );
-        }
-
-        // Stop once we get stuck at the same address.
-        return addr === processor.getPrevPc(1);
-    });
-    console.log("Running Dormann " + name + " tests...");
-    processor.execute(2000000 * 60);
-    console.log(`Run complete at $${utils.hexword(processor.pc)}`);
-    const result = processor.pc === expectedPc;
-    if (!result) logFailure(processor);
-    return result;
-}
-
-function logFailure(processor) {
-    console.log("Failed at " + utils.hexword(processor.pc));
-    console.log("Previous PCs:");
-    for (let i = 1; i < 16; ++i) {
-        console.log("  " + utils.hexword(processor.getPrevPc(i)));
-    }
-    console.log("A: " + utils.hexbyte(processor.a));
-    console.log("X: " + utils.hexbyte(processor.x));
-    console.log("Y: " + utils.hexbyte(processor.y));
-    console.log("S: " + utils.hexbyte(processor.s));
-    console.log("P: " + utils.hexbyte(processor.p.asByte()) + " " + processor.p.debugString());
-    console.log(
-        utils.hd(
-            function (i) {
-                return processor.readmem(i);
-            },
-            0x00,
-            0x40,
-        ),
-    );
-}
-
-describe("dormann tests", { timeout: 30000 }, function () {
-    it("should pass 6502 functional tests", async () => {
-        const cpu = fake6502();
-        await cpu.initialise();
-        assert(await runTest(cpu, "6502_functional_test", "6502"));
-    });
-    it("should pass 65c02 extended opcode tests", async () => {
-        const cpu = fake65C02();
-        await cpu.initialise();
-        assert(await runTest(cpu, "65C02_extended_opcodes_test", "65C02"));
-    });
-    it("should pass 65c12 extended opcode tests", async () => {
-        const cpu = fake65C12();
-        await cpu.initialise();
-        assert(await runTest(cpu, "65C12_extended_opcodes_test", "65C12"));
-    });
-});

package/tests/integration/dp111timing.js

@@ -1,42 +0,0 @@
-import { describe, it } from "vitest";
-import { TestMachine } from "../test-machine.js";
-import assert from "assert";
-
-describe("test dp111's timing tests", { timeout: 30000 }, function () {
-    const doTest = async (disc, machine) => {
-        const testMachine = new TestMachine(machine);
-        await testMachine.initialise();
-        await testMachine.loadDisc(`tests/integration/dp111_6502Timing/${disc}.ssd`);
-        await testMachine.runUntilInput();
-        let output = "";
-        testMachine.captureText((elem) => {
-            output += `${elem.text}\n`;
-        });
-        await testMachine.type("*RUN 6502TIM");
-        let numFailedTests = null;
-        const hook = testMachine.processor.debugWrite.add((addr, value) => {
-            if (addr === 0xfcd0) {
-                numFailedTests = value;
-            }
-        });
-        await testMachine.runUntilInput();
-        hook.remove();
-        if (numFailedTests) {
-            console.log(`Test failed, output:\n${output}`);
-        }
-        assert.equal(numFailedTests, 0);
-    };
-    it("should handle 6502timing", async () => {
-        await doTest("6502timing");
-    });
-    it("should handle 6502timing with 1MHz bus", async () => {
-        await doTest("6502timing1M");
-    });
-
-    it("should handle 65C12timing", async () => {
-        await doTest("65C12timing", "Master");
-    });
-    it("should handle 65C12timing with 1MHz bus", async () => {
-        await doTest("65C12timing1M", "Master");
-    });
-});

package/tests/integration/ensure-submodules.js

@@ -1,25 +0,0 @@
-import { describe, it } from "vitest";
-import assert from "assert";
-import * as fs from "fs";
-
-describe("ensure git submodules are present", function () {
-    it("should have functional tests", function () {
-        try {
-            fs.accessSync("tests/6502_65C02_functional_tests/README.md");
-        } catch {
-            assert.fail(
-                "Functional tests submodule missing. Ensure git submodules are fetched (git submodule update --init).",
-            );
-        }
-    });
-
-    it("should have timing tests", function () {
-        try {
-            fs.accessSync("tests/integration/dp111_6502Timing/README.md");
-        } catch {
-            assert.fail(
-                "Timing tests submodule missing. Ensure git submodules are fetched  (git submodule update --init).",
-            );
-        }
-    });
-});

package/tests/integration/nops.bas

@@ -1,119 +0,0 @@
-1REM Thanks to Tom Seddon!
-10REM>NOPS
-20MODE1
-30PRINX%=0:PRINY%=0:COLWIDTH%=0
-40CODESIZE%=1000:DIMCODE%CODESIZE%
-50:
-60FORPASS%=0TO2STEP2:P%=CODE%:[OPTPASS%
-70LDA&60:PHA
-80LDA#0:STA&60
-90JSRSMBTEST
-100LDA&60:STA&70
-110PLA:STA&60
-120RTS
-130:
-140.SMBTEST
-150EQUB&87:EQUB&60:\SMB0 &60
-160RTS
-170]
-180NEXT
-190CALLCODE%
-200ROCKWELL%=?&70<>0
-210IFROCKWELL%:PROCPRINT(3,0,"ROCKWELL/WDC CPU"):ELSE:PROCPRINT(3,0,"CMOS CPU")
-220PROCPRINT(0,1,"2 CYCLES")
-230T2C%=FNTIME(1,&EA,1,-1)
-240PROCPRINT(0,1,"3 CYCLES")
-250T3C%=FNTIME(1,&A5,2,-1)
-260PROCPRINT(0,1,"4 CYCLES")
-270T4C%=FNTIME(1,&AD,3,-1)
-271PROCPRINT(0,1,"8 CYCLES")
-272T8C%=FNTIME(2,&AD,3,-1)
-273PROCPRINT(0,1,"1 CYCLES")
-274T1C%=T2C%-INT(((T3C%-T2C%)+(T4C%-T2C%)/2+(T8C%-T2C%)/6)/3)
-275PROCPRINT(0,3,"GUESS: "+STR$T1C%)
-280RESTORE560:PROCMULTI(T2C%,2,2)
-290RESTORE580:PROCMULTI(T3C%,3,2)
-300RESTORE620:PROCMULTI(T4C%,4,2)
-310RESTORE680:PROCMULTI(T8C%,8,3)
-320RESTORE410:PROCMULTI(-1,1,1)
-330IFNOTROCKWELL%:RESTORE440:PROCMULTI(-1,1,1)
-340RESTORE470:PROCMULTI(-1,1,1)
-350IFNOTROCKWELL%:RESTORE500:PROCMULTI(-1,1,1)
-360IFNOTROCKWELL%:RESTORE530:PROCMULTI(-1,1,1)
-370END
-380:
-390:
-400REM 1 CYCLES, 1 BYTES
-410DATA &03,&13,&23,&33,&43,&53,&63,&73,&83,&93,&A3,&B3,&C3,&D3,&E3,&F3,-1
-420:
-430REM 1 CYCLES, 1 BYTES (NOT ROCKWELL)
-440DATA &07,&17,&27,&37,&47,&57,&67,&77,&87,&97,&A7,&B7,&C7,&D7,&E7,&F7,-1
-450:
-460REM 1 CYCLES, 1 BYTES
-470DATA &0B,&1B,&2B,&3B,&4B,&5B,&6B,&7B,&8B,&9B,&AB,&BB,&EB,&FB,-1
-480:
-490REM 1 CYCLES, 1 BYTES (NOT WDC)
-500DATA &CB,&DB,-1
-510:
-520REM 1 CYCLES, 1 BYTES (NOT ROCKWELL)
-530DATA &0F,&1F,&2F,&3F,&4F,&5F,&6F,&7F,&8F,&9F,&AF,&BF,&CF,&DF,&EF,&FF,-1
-540:
-550REM 2 CYCLES, 2 BYTES
-560DATA &02,&22,&42,&62,&82,&C2,&E2,-1
-570:
-580REM 3 CYCLES, 2 BYTES
-590DATA &44,-1
-600:
-610REM 4 CYCLES, 2 BYTES
-620DATA &54,&D4,&F4,-1
-630:
-640REM 4 CYCLES, 3 BYTES
-650DATA &DC,&FC,-1
-660:
-670REM 8 CYCLES, 3 BYTES
-680DATA &5C,-1
-690:
-700DEFPROCMULTI(TEXPECTED%,NC%,NB%)
-710PROCPRINT(0,2,STR$NC%+" CYCLES")
-720REPEAT
-730READNOP%:IFNOP%=-1:GOTO750
-740T%=FNTIME(1,NOP%,NB%,TEXPECTED%)
-750UNTILNOP%=-1
-760ENDPROC
-770:
-780DEFFNTIME(NCOPIES%,NOP%,N%,TEXPECTED%)
-790IFN%<1ORN%>3:STOP
-800FORPASS%=0TO2STEP2:P%=CODE%:[OPTPASS%
-810.START
-820LDX#0
-830.XLOOP
-840LDY#0
-850.YLOOP
-860]
-870FORI%=1TONCOPIES%*10
-880[OPTPASS%:EQUBNOP%:]
-890IFN%>=2:[OPTPASS%:EQUB0:]
-900IFN%>=3:[OPTPASS%:EQUB0:]
-910NEXT
-920[OPTPASS%
-930DEY:BNEYLOOP
-940DEX:BNEXLOOP
-950RTS
-960]IFP%>CODE%+CODESIZE%:STOP
-970NEXT
-980TIME=0
-990REMPRINTFNHEX2(NOP%)" (";N%"): ";
-1000CALLSTART
-1010T%=TIME
-1020IFTEXPECTED%>=0ANDABS(TIME-TEXPECTED%)>2:B%=1:ELSE:B%=0
-1030PROCPRINT(B%,3,FNHEX2(NOP%)+" ("+STR$N%+"): "+STR$T%)
-1040=T%
-1050DEFFNHEX2(X%)=RIGHT$("0"+STR$~X%,2)
-1060DEFPROCPRINT(B%,F%,MSG$)
-1070COLOUR128+B%:COLOURF%
-1080PRINTTAB(PRINX%,PRINY%);MSG$;
-1090COLOUR128:COLOUR7
-1100IFLENMSG$>COLWIDTH%:COLWIDTH%=LENMSG$
-1110PRINY%=PRINY%+1
-1120IFPRINY%=32:PRINY%=0:PRINX%=PRINX%+COLWIDTH%+1:COLWIDTH%=0
-1130ENDPROC

package/tests/integration/nops.js

@@ -1,24 +0,0 @@
-import { describe, it } from "vitest";
-import assert from "assert";
-import * as utils from "../../src/utils.js";
-import { TestMachine } from "../test-machine.js";
-
-describe("test various NOP timings", { timeout: 30000 }, function () {
-    it("should match the nops.bas code", async () => {
-        const testMachine = new TestMachine("Master");
-        await testMachine.initialise();
-        await testMachine.runUntilInput();
-        const data = await utils.loadData("tests/integration/nops.bas");
-        await testMachine.loadBasic(utils.uint8ArrayToString(data));
-
-        let numCaptures = 0;
-        testMachine.captureText((elem) => {
-            assert(elem.background !== 1, `Failure from test - ${JSON.stringify(elem)}`);
-            console.log(`emulator output: ${elem.text}`);
-            numCaptures++;
-        });
-        await testMachine.type("RUN");
-        await testMachine.runUntilInput(2 * 60);
-        assert(numCaptures === 97, "Missing output");
-    });
-});