jsbeeb 1.1.1

package/tests/unit/test-tokenise.js

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import * as Tokeniser from "../../src/basic-tokenise.js";
+const tokeniser = Tokeniser.create();
+
+describe("Tokeniser", function () {
+    "use strict";
+
+    async function check(text, expected) {
+        try {
+            const t = await tokeniser;
+            expect(t.tokenise(text)).toBe(expected);
+        } catch (e) {
+            console.log("Failed:", e);
+            expect(e).toBe("");
+        }
+    }
+
+    async function checkThrows(text, expectedError) {
+        try {
+            const t = await tokeniser;
+            t.tokenise(text);
+            console.log("Failed to give exception with message:", expectedError);
+            expect.fail("Expected an exception to be thrown");
+        } catch (e) {
+            expect(e.message).toBe(expectedError);
+        }
+    }
+
+    it("handles a simple program", async function () {
+        await check(
+            '10 PRINT "hello"\n20 GOTO 10\n',
+            '\r\x00\x0a\x0e \xf1 "hello"\r\x00\x14\x0b \xe5 \x8d\x54\x4a\x40\r\xff',
+        );
+    });
+    it("handles assignment to HIMEM", async function () {
+        await check("HIMEM=&6000", "\r\x00\x0a\x0b\xd3=&6000\r\xff");
+    });
+    it("handles reading from HIMEM", async function () {
+        await check("PRINT HIMEM", "\r\x00\x0a\x07\xf1 \x93\r\xff");
+    });
+    it("deals with colons", async function () {
+        await check("PRINT HIMEM:HIMEM=&6000", "\r\x00\x0a\x0f\xf1 \x93:\xd3=&6000\r\xff");
+    });
+    it("handles MODE", async function () {
+        await check("IF0ELSEMODE0", "\r\x00\x0a\x09\xe70\x8b\xeb0\r\xff");
+    });
+    it("handles a snippet from one line Tetris", async function () {
+        await check(
+            "d=d:IFd VDUd:p=POINT(64*POS,1E3-VPOS*32):RETURN ELSEMODE2:GCOL0,-9:CLG",
+            "\r\x00\x0a\x2dd=d:\xe7d \xefd:p=\xb064*\xb1,1E3-\xbc*32):\xf8 \x8b\xeb2:\xe60,-9:\xda\r\xff",
+        );
+    });
+    it("copes with token names inside strings", async function () {
+        await check('PRINT "IF ""IF"" IF"', '\r\x00\x0a\x14\xf1 "IF ""IF"" IF"\r\xff');
+    });
+    it("handles REM", async function () {
+        await check("10REM I am a monkey", "\r\x00\x0a\x13\xf4 I am a monkey\r\xff");
+    });
+    it("handles extra long input", async function () {
+        await check("10" + "ENVELOPE".repeat(251), "\r\x00\x0a\xff" + "\xe2".repeat(251) + "\r\xff");
+    });
+    it("gives error for overlong input", async function () {
+        await checkThrows("10" + "ENVELOPE".repeat(252), "Line 10 tokenised length 252 > 251 bytes");
+    });
+});

package/tests/unit/test-url-params.js

@@ -0,0 +1,398 @@
+import { describe, it, expect, vi } from "vitest";
+
+import {
+    parseQueryString,
+    buildUrlFromParams,
+    processKeyboardParams,
+    processAutobootParams,
+    parseMediaParams,
+    guessModelFromHostname,
+    ParamTypes,
+} from "../../src/url-params.js";
+
+describe("URL Parameters", () => {
+    describe("parseQueryString", () => {
+        it("should parse empty query string", () => {
+            expect(parseQueryString("")).toEqual({});
+        });
+
+        it("should parse basic query string parameters", () => {
+            const qs = "model=B&disc=elite.ssd";
+            expect(parseQueryString(qs)).toEqual({
+                model: "B",
+                disc: "elite.ssd",
+            });
+        });
+
+        it("should handle URL encoded components", () => {
+            const qs = "text=Hello%20World&path=file%2Fname.txt";
+            expect(parseQueryString(qs)).toEqual({
+                text: "Hello World",
+                path: "file/name.txt",
+            });
+        });
+
+        it("should handle parameters without values", () => {
+            const qs = "debug&verbose&disc=test.ssd&noseek";
+            expect(parseQueryString(qs)).toEqual({
+                debug: null,
+                verbose: null,
+                disc: "test.ssd",
+                noseek: null,
+            });
+        });
+
+        it("should handle query strings ending with /", () => {
+            const qs = "model=B&disc=elite.ssd/";
+            expect(parseQueryString(qs)).toEqual({
+                model: "B",
+                disc: "elite.ssd",
+            });
+        });
+
+        it("should handle array parameters", () => {
+            const qs = "rom=os.rom&rom=basic.rom&rom=dfs.rom&model=B";
+            expect(parseQueryString(qs, { rom: ParamTypes.ARRAY })).toEqual({
+                rom: ["os.rom", "basic.rom", "dfs.rom"],
+                model: "B",
+            });
+        });
+
+        it("should handle array parameters with single value", () => {
+            const qs = "rom=os.rom&model=B";
+            expect(parseQueryString(qs, { rom: ParamTypes.ARRAY })).toEqual({
+                rom: ["os.rom"],
+                model: "B",
+            });
+        });
+
+        it("should handle empty array parameters", () => {
+            const qs = "rom=&model=B";
+            expect(parseQueryString(qs, { rom: ParamTypes.ARRAY })).toEqual({
+                rom: [""],
+                model: "B",
+            });
+        });
+
+        it("should handle multiple array parameter types", () => {
+            const qs = "rom=os.rom&rom=basic.rom&disc=elite.ssd&disc=other.ssd";
+            expect(parseQueryString(qs, { rom: ParamTypes.ARRAY, disc: ParamTypes.ARRAY })).toEqual({
+                rom: ["os.rom", "basic.rom"],
+                disc: ["elite.ssd", "other.ssd"],
+            });
+        });
+
+        // Tests for new parameter types
+        it("should parse parameter types - string", () => {
+            const qs = "name=jsbeeb&title=BBC%20Emulator";
+            expect(parseQueryString(qs, { name: ParamTypes.STRING, title: ParamTypes.STRING })).toEqual({
+                name: "jsbeeb",
+                title: "BBC Emulator",
+            });
+        });
+
+        it("should parse parameter types - int", () => {
+            const qs = "speed=100&cycles=50";
+            expect(parseQueryString(qs, { speed: ParamTypes.INT, cycles: ParamTypes.INT })).toEqual({
+                speed: 100,
+                cycles: 50,
+            });
+        });
+
+        it("should parse parameter types - float", () => {
+            const qs = "volume=0.5&zoom=1.25";
+            expect(parseQueryString(qs, { volume: ParamTypes.FLOAT, zoom: ParamTypes.FLOAT })).toEqual({
+                volume: 0.5,
+                zoom: 1.25,
+            });
+        });
+
+        it("should parse parameter types - bool", () => {
+            const qs = "debug&verbose=false&noseek=true";
+            expect(
+                parseQueryString(qs, { debug: ParamTypes.BOOL, verbose: ParamTypes.BOOL, noseek: ParamTypes.BOOL }),
+            ).toEqual({
+                debug: true,
+                verbose: false,
+                noseek: true,
+            });
+        });
+
+        it("should handle mixed parameter types", () => {
+            const qs = "model=B&rom=os.rom&rom=basic.rom&speed=4&volume=0.8&debug";
+            const paramTypes = {
+                model: ParamTypes.STRING,
+                rom: ParamTypes.ARRAY,
+                speed: ParamTypes.INT,
+                volume: ParamTypes.FLOAT,
+                debug: ParamTypes.BOOL,
+            };
+
+            expect(parseQueryString(qs, paramTypes)).toEqual({
+                model: "B",
+                rom: ["os.rom", "basic.rom"],
+                speed: 4,
+                volume: 0.8,
+                debug: true,
+            });
+        });
+    });
+
+    describe("buildUrlFromParams", () => {
+        const baseUrl = "http://localhost:8080/index.html";
+
+        it("should build URL with basic parameters", () => {
+            const params = { model: "B", disc: "elite.ssd" };
+            expect(buildUrlFromParams(baseUrl, params)).toBe("http://localhost:8080/index.html?model=B&disc=elite.ssd");
+        });
+
+        it("should handle array parameters in URL", () => {
+            const params = {
+                model: "B",
+                rom: ["os.rom", "basic.rom", "dfs.rom"],
+            };
+            expect(buildUrlFromParams(baseUrl, params, { rom: ParamTypes.ARRAY })).toBe(
+                "http://localhost:8080/index.html?model=B&rom=os.rom&rom=basic.rom&rom=dfs.rom",
+            );
+        });
+
+        it("should skip empty or falsy values", () => {
+            const params = {
+                model: "B",
+                disc: "",
+                debug: null,
+                rom: [],
+            };
+            expect(buildUrlFromParams(baseUrl, params, { rom: ParamTypes.ARRAY })).toBe(
+                "http://localhost:8080/index.html?model=B",
+            );
+        });
+
+        it("should handle mixed parameter types", () => {
+            const params = {
+                model: "B",
+                disc: "test.ssd",
+                rom: ["os.rom", "basic.rom"],
+            };
+            expect(buildUrlFromParams(baseUrl, params, { rom: ParamTypes.ARRAY })).toBe(
+                "http://localhost:8080/index.html?model=B&disc=test.ssd&rom=os.rom&rom=basic.rom",
+            );
+        });
+
+        // Tests for new parameter types with buildUrlFromParams
+        it("should build URL with typed parameters", () => {
+            const params = {
+                model: "B",
+                rom: ["os.rom", "basic.rom"],
+                speed: 4,
+                volume: 0.8,
+                debug: true,
+                noseek: false, // Should be omitted as it's false
+            };
+
+            const paramTypes = {
+                model: ParamTypes.STRING,
+                rom: ParamTypes.ARRAY,
+                speed: ParamTypes.INT,
+                volume: ParamTypes.FLOAT,
+                debug: ParamTypes.BOOL,
+                noseek: ParamTypes.BOOL,
+            };
+
+            expect(buildUrlFromParams(baseUrl, params, paramTypes)).toBe(
+                "http://localhost:8080/index.html?model=B&rom=os.rom&rom=basic.rom&speed=4&volume=0.8&debug",
+            );
+        });
+
+        it("should handle zero values correctly", () => {
+            const params = {
+                speed: 0,
+                volume: 0.0,
+            };
+
+            const paramTypes = {
+                speed: ParamTypes.INT,
+                volume: ParamTypes.FLOAT,
+            };
+
+            expect(buildUrlFromParams(baseUrl, params, paramTypes)).toBe(
+                "http://localhost:8080/index.html?speed=0&volume=0",
+            );
+        });
+    });
+
+    describe("processKeyboardParams", () => {
+        it("should process keyboard mappings", () => {
+            const BBC = { CTRL: "CTRL", SHIFT: "SHIFT" };
+            const keyCodes = { A: 65, B: 66 };
+            const userKeymap = [];
+            const gamepad = { remap: vi.fn() };
+
+            const parsedQuery = {
+                "KEY.A": "CTRL",
+                "KEY.B": "SHIFT",
+                "GP.FIRE2": "RETURN",
+                UP: "Q",
+                other: "value",
+            };
+
+            processKeyboardParams(parsedQuery, BBC, keyCodes, userKeymap, gamepad);
+
+            expect(userKeymap).toEqual([
+                { native: "A", bbc: "CTRL" },
+                { native: "B", bbc: "SHIFT" },
+            ]);
+
+            expect(gamepad.remap).toHaveBeenCalledTimes(2);
+            expect(gamepad.remap).toHaveBeenCalledWith("FIRE2", "RETURN");
+            expect(gamepad.remap).toHaveBeenCalledWith("UP", "Q");
+        });
+    });
+
+    describe("processAutobootParams", () => {
+        it("should process autoboot parameters with boolean values", () => {
+            const params = {
+                autoboot: true,
+                other: "value",
+            };
+            expect(processAutobootParams(params)).toEqual({
+                needsAutoboot: "boot",
+                autoType: "",
+            });
+
+            expect(processAutobootParams({ autochain: true })).toEqual({
+                needsAutoboot: "chain",
+                autoType: "",
+            });
+
+            expect(processAutobootParams({ autorun: true })).toEqual({
+                needsAutoboot: "run",
+                autoType: "",
+            });
+
+            expect(processAutobootParams({ autotype: "HELLO" })).toEqual({
+                needsAutoboot: "type",
+                autoType: "HELLO",
+            });
+
+            expect(processAutobootParams({ other: "value" })).toEqual({
+                needsAutoboot: false,
+                autoType: "",
+            });
+        });
+
+        it("should handle legacy autoboot parameters (backward compatibility)", () => {
+            // For backward compatibility, handle string values from parseQueryString legacy mode
+            expect(processAutobootParams({ autoboot: "" })).toEqual({
+                needsAutoboot: "boot",
+                autoType: "",
+            });
+
+            expect(processAutobootParams({ autochain: "" })).toEqual({
+                needsAutoboot: "chain",
+                autoType: "",
+            });
+
+            expect(processAutobootParams({ autorun: "" })).toEqual({
+                needsAutoboot: "run",
+                autoType: "",
+            });
+        });
+    });
+
+    describe("parseMediaParams", () => {
+        it("should extract disc and tape images from query params", () => {
+            const params = {
+                disc: "elite.ssd",
+                disc2: "games.ssd",
+                tape: "welcome.uef",
+                other: "value",
+            };
+
+            expect(parseMediaParams(params)).toEqual({
+                discImage: "elite.ssd",
+                secondDiscImage: "games.ssd",
+                tapeImage: "welcome.uef",
+            });
+
+            expect(parseMediaParams({ disc1: "disc1.ssd" })).toEqual({
+                discImage: "disc1.ssd",
+                secondDiscImage: undefined,
+                tapeImage: undefined,
+            });
+        });
+    });
+
+    describe("guessModelFromHostname", () => {
+        it("should return B-DFS1.2 for hostnames starting with 'bbc'", () => {
+            expect(guessModelFromHostname("bbc.example.com")).toBe("B-DFS1.2");
+            expect(guessModelFromHostname("bbcmicro.local")).toBe("B-DFS1.2");
+        });
+
+        it("should return Master for hostnames starting with 'master'", () => {
+            expect(guessModelFromHostname("master.example.com")).toBe("Master");
+            expect(guessModelFromHostname("mastercompact.local")).toBe("Master");
+        });
+
+        it("should return default model for other hostnames", () => {
+            expect(guessModelFromHostname("example.com")).toBe("B-DFS1.2");
+            expect(guessModelFromHostname("localhost")).toBe("B-DFS1.2");
+            expect(guessModelFromHostname("")).toBe("B-DFS1.2");
+        });
+    });
+
+    describe("parseQueryString additional tests", () => {
+        it("should handle invalid/malformed query strings", () => {
+            expect(parseQueryString("=value")).toEqual({ "": "value" });
+            expect(parseQueryString("key=")).toEqual({ key: "" });
+            expect(parseQueryString("&&&")).toEqual({});
+            expect(parseQueryString("key&key=value")).toEqual({ key: "value" });
+        });
+
+        it("should handle special characters in query parameters", () => {
+            const qs = "text=Hello%20%26%20World%21&file=file%2Bname%40domain.com";
+            expect(parseQueryString(qs)).toEqual({
+                text: "Hello & World!",
+                file: "file+name@domain.com",
+            });
+        });
+    });
+
+    describe("buildUrlFromParams additional tests", () => {
+        const baseUrl = "http://localhost:8080/index.html";
+
+        it("should handle empty parameter object", () => {
+            expect(buildUrlFromParams(baseUrl, {})).toBe(baseUrl);
+        });
+
+        it("should encode special characters in URL parameters", () => {
+            const params = {
+                text: "Hello & World!",
+                file: "file+name@domain.com",
+            };
+            const expected = "http://localhost:8080/index.html?text=Hello%20%26%20World!&file=file%2Bname%40domain.com";
+            expect(buildUrlFromParams(baseUrl, params)).toBe(expected);
+        });
+
+        it("should handle explicit parameter types", () => {
+            const params = {
+                name: "jsbeeb",
+                roms: ["os.rom", "basic.rom"],
+                debug: true,
+            };
+
+            // With ARRAY type for roms - we should get separate parameters
+            expect(buildUrlFromParams(baseUrl, params, { roms: ParamTypes.ARRAY })).toBe(
+                "http://localhost:8080/index.html?name=jsbeeb&roms=os.rom&roms=basic.rom&debug=true",
+            );
+
+            // With BOOL type for debug and ARRAY type for roms
+            expect(
+                buildUrlFromParams(baseUrl, params, {
+                    debug: ParamTypes.BOOL,
+                    roms: ParamTypes.ARRAY,
+                }),
+            ).toBe("http://localhost:8080/index.html?name=jsbeeb&roms=os.rom&roms=basic.rom&debug");
+        });
+    });
+});