完善虚拟机连接

VM/novnc/tests/assertions.js

@@ -0,0 +1,96 @@
+// noVNC specific assertions
+chai.use(function (_chai, utils) {
+    function _equal(a, b) {
+        return a === b;
+    }
+    _chai.Assertion.addMethod('displayed', function (targetData, cmp=_equal) {
+        const obj = this._obj;
+        const ctx = obj._target.getContext('2d');
+        const data = ctx.getImageData(0, 0, obj._target.width, obj._target.height).data;
+        const len = data.length;
+        new chai.Assertion(len).to.be.equal(targetData.length, "unexpected display size");
+        let same = true;
+        for (let i = 0; i < len; i++) {
+            if (!cmp(data[i], targetData[i])) {
+                same = false;
+                break;
+            }
+        }
+        if (!same) {
+            // eslint-disable-next-line no-console
+            console.log("expected data: %o, actual data: %o", targetData, data);
+        }
+        this.assert(same,
+                    "expected #{this} to have displayed the image #{exp}, but instead it displayed #{act}",
+                    "expected #{this} not to have displayed the image #{act}",
+                    targetData,
+                    data);
+    });
+
+    _chai.Assertion.addMethod('sent', function (targetData) {
+        const obj = this._obj;
+        const data = obj._websocket._getSentData();
+        let same = true;
+        if (data.length != targetData.length) {
+            same = false;
+        } else {
+            for (let i = 0; i < data.length; i++) {
+                if (data[i] != targetData[i]) {
+                    same = false;
+                    break;
+                }
+            }
+        }
+        if (!same) {
+            // eslint-disable-next-line no-console
+            console.log("expected data: %o, actual data: %o", targetData, data);
+        }
+        this.assert(same,
+                    "expected #{this} to have sent the data #{exp}, but it actually sent #{act}",
+                    "expected #{this} not to have sent the data #{act}",
+                    Array.prototype.slice.call(targetData),
+                    Array.prototype.slice.call(data));
+    });
+
+    _chai.Assertion.addProperty('array', function () {
+        utils.flag(this, 'array', true);
+    });
+
+    _chai.Assertion.overwriteMethod('equal', function (_super) {
+        return function assertArrayEqual(target) {
+            if (utils.flag(this, 'array')) {
+                const obj = this._obj;
+
+                let same = true;
+
+                if (utils.flag(this, 'deep')) {
+                    for (let i = 0; i < obj.length; i++) {
+                        if (!utils.eql(obj[i], target[i])) {
+                            same = false;
+                            break;
+                        }
+                    }
+
+                    this.assert(same,
+                                "expected #{this} to have elements deeply equal to #{exp}",
+                                "expected #{this} not to have elements deeply equal to #{exp}",
+                                Array.prototype.slice.call(target));
+                } else {
+                    for (let i = 0; i < obj.length; i++) {
+                        if (obj[i] != target[i]) {
+                            same = false;
+                            break;
+                        }
+                    }
+
+                    this.assert(same,
+                                "expected #{this} to have elements equal to #{exp}",
+                                "expected #{this} not to have elements equal to #{exp}",
+                                Array.prototype.slice.call(target));
+                }
+            } else {
+                _super.apply(this, arguments);
+            }
+        };
+    });
+});

VM/novnc/tests/fake.websocket.js

@@ -0,0 +1,92 @@
+import Base64 from '../core/base64.js';
+
+export default class FakeWebSocket {
+    constructor(uri, protocols) {
+        this.url = uri;
+        this.binaryType = "arraybuffer";
+        this.extensions = "";
+
+        this.onerror = null;
+        this.onmessage = null;
+        this.onopen = null;
+
+        if (!protocols || typeof protocols === 'string') {
+            this.protocol = protocols;
+        } else {
+            this.protocol = protocols[0];
+        }
+
+        this._sendQueue = new Uint8Array(20000);
+
+        this.readyState = FakeWebSocket.CONNECTING;
+        this.bufferedAmount = 0;
+
+        this._isFake = true;
+    }
+
+    close(code, reason) {
+        this.readyState = FakeWebSocket.CLOSED;
+        if (this.onclose) {
+            this.onclose(new CloseEvent("close", { 'code': code, 'reason': reason, 'wasClean': true }));
+        }
+    }
+
+    send(data) {
+        if (this.protocol == 'base64') {
+            data = Base64.decode(data);
+        } else {
+            data = new Uint8Array(data);
+        }
+        this._sendQueue.set(data, this.bufferedAmount);
+        this.bufferedAmount += data.length;
+    }
+
+    _getSentData() {
+        const res = this._sendQueue.slice(0, this.bufferedAmount);
+        this.bufferedAmount = 0;
+        return res;
+    }
+
+    _open() {
+        this.readyState = FakeWebSocket.OPEN;
+        if (this.onopen) {
+            this.onopen(new Event('open'));
+        }
+    }
+
+    _receiveData(data) {
+        if (data.length < 4096) {
+            // Break apart the data to expose bugs where we assume data is
+            // neatly packaged
+            for (let i = 0;i < data.length;i++) {
+                let buf = data.slice(i, i+1);
+                this.onmessage(new MessageEvent("message", { 'data': buf.buffer }));
+            }
+        } else {
+            this.onmessage(new MessageEvent("message", { 'data': data.buffer }));
+        }
+    }
+}
+
+FakeWebSocket.OPEN = WebSocket.OPEN;
+FakeWebSocket.CONNECTING = WebSocket.CONNECTING;
+FakeWebSocket.CLOSING = WebSocket.CLOSING;
+FakeWebSocket.CLOSED = WebSocket.CLOSED;
+
+FakeWebSocket._isFake = true;
+
+FakeWebSocket.replace = () => {
+    if (!WebSocket._isFake) {
+        const realVersion = WebSocket;
+        // eslint-disable-next-line no-global-assign
+        WebSocket = FakeWebSocket;
+        FakeWebSocket._realVersion = realVersion;
+    }
+};
+
+FakeWebSocket.restore = () => {
+    if (WebSocket._isFake) {
+        // eslint-disable-next-line no-global-assign
+        WebSocket = WebSocket._realVersion;
+    }
+};

VM/novnc/tests/playback-ui.js

@@ -0,0 +1,218 @@
+/* global VNC_frame_data, VNC_frame_encoding */
+
+import * as WebUtil from '../app/webutil.js';
+import RecordingPlayer from './playback.js';
+import Base64 from '../core/base64.js';
+
+let frames = null;
+
+function message(str) {
+    const cell = document.getElementById('messages');
+    cell.textContent += str + "\n";
+    cell.scrollTop = cell.scrollHeight;
+}
+
+function loadFile() {
+    const fname = WebUtil.getQueryVar('data', null);
+
+    if (!fname) {
+        return Promise.reject("Must specify data=FOO in query string.");
+    }
+
+    message("Loading " + fname + "...");
+
+    return new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.onload = resolve;
+        script.onerror = () => { reject("Failed to load " + fname); };
+        document.body.appendChild(script);
+        script.src = "../recordings/" + fname;
+    });
+}
+
+function enableUI() {
+    const iterations = WebUtil.getQueryVar('iterations', 3);
+    document.getElementById('iterations').value = iterations;
+
+    const mode = WebUtil.getQueryVar('mode', 3);
+    if (mode === 'realtime') {
+        document.getElementById('mode2').checked = true;
+    } else {
+        document.getElementById('mode1').checked = true;
+    }
+
+    /* eslint-disable-next-line camelcase */
+    message("Loaded " + VNC_frame_data.length + " frames");
+
+    const startButton = document.getElementById('startButton');
+    startButton.disabled = false;
+    startButton.addEventListener('click', start);
+
+    message("Converting...");
+
+    /* eslint-disable-next-line camelcase */
+    frames = VNC_frame_data;
+
+    let encoding;
+
+    /* eslint-disable camelcase */
+    if (window.VNC_frame_encoding) {
+        // Only present in older recordings
+        encoding = VNC_frame_encoding;
+    /* eslint-enable camelcase */
+    } else {
+        let frame = frames[0];
+        let start = frame.indexOf('{', 1) + 1;
+        if (frame.slice(start, start+4) === 'UkZC') {
+            encoding = 'base64';
+        } else {
+            encoding = 'binary';
+        }
+    }
+
+    for (let i = 0;i < frames.length;i++) {
+        let frame = frames[i];
+
+        if (frame === "EOF") {
+            frames.splice(i);
+            break;
+        }
+
+        let dataIdx = frame.indexOf('{', 1) + 1;
+
+        let time = parseInt(frame.slice(1, dataIdx - 1));
+
+        let u8;
+        if (encoding === 'base64') {
+            u8 = Base64.decode(frame.slice(dataIdx));
+        } else {
+            u8 = new Uint8Array(frame.length - dataIdx);
+            for (let j = 0; j < frame.length - dataIdx; j++) {
+                u8[j] = frame.charCodeAt(dataIdx + j);
+            }
+        }
+
+        frames[i] = { fromClient: frame[0] === '}',
+                      timestamp: time,
+                      data: u8 };
+    }
+
+    message("Ready");
+}
+
+class IterationPlayer {
+    constructor(iterations, frames) {
+        this._iterations = iterations;
+
+        this._iteration = undefined;
+        this._player = undefined;
+
+        this._startTime = undefined;
+
+        this._frames = frames;
+
+        this._state = 'running';
+
+        this.onfinish = () => {};
+        this.oniterationfinish = () => {};
+        this.rfbdisconnected = () => {};
+    }
+
+    start(realtime) {
+        this._iteration = 0;
+        this._startTime = (new Date()).getTime();
+
+        this._realtime = realtime;
+
+        this._nextIteration();
+    }
+
+    _nextIteration() {
+        const player = new RecordingPlayer(this._frames, this._disconnected.bind(this));
+        player.onfinish = this._iterationFinish.bind(this);
+
+        if (this._state !== 'running') { return; }
+
+        this._iteration++;
+        if (this._iteration > this._iterations) {
+            this._finish();
+            return;
+        }
+
+        player.run(this._realtime, false);
+    }
+
+    _finish() {
+        const endTime = (new Date()).getTime();
+        const totalDuration = endTime - this._startTime;
+
+        const evt = new CustomEvent('finish',
+                                    { detail:
+                                      { duration: totalDuration,
+                                        iterations: this._iterations } } );
+        this.onfinish(evt);
+    }
+
+    _iterationFinish(duration) {
+        const evt = new CustomEvent('iterationfinish',
+                                    { detail:
+                                      { duration: duration,
+                                        number: this._iteration } } );
+        this.oniterationfinish(evt);
+
+        this._nextIteration();
+    }
+
+    _disconnected(clean, frame) {
+        if (!clean) {
+            this._state = 'failed';
+        }
+
+        const evt = new CustomEvent('rfbdisconnected',
+                                    { detail:
+                                      { clean: clean,
+                                        frame: frame,
+                                        iteration: this._iteration } } );
+        this.onrfbdisconnected(evt);
+    }
+}
+
+function start() {
+    document.getElementById('startButton').value = "Running";
+    document.getElementById('startButton').disabled = true;
+
+    const iterations = document.getElementById('iterations').value;
+
+    let realtime;
+
+    if (document.getElementById('mode1').checked) {
+        message(`Starting performance playback (fullspeed) [${iterations} iteration(s)]`);
+        realtime = false;
+    } else {
+        message(`Starting realtime playback [${iterations} iteration(s)]`);
+        realtime = true;
+    }
+
+    const player = new IterationPlayer(iterations, frames);
+    player.oniterationfinish = (evt) => {
+        message(`Iteration ${evt.detail.number} took ${evt.detail.duration}ms`);
+    };
+    player.onrfbdisconnected = (evt) => {
+        if (!evt.detail.clean) {
+            message(`noVNC sent disconnected during iteration ${evt.detail.iteration} frame ${evt.detail.frame}`);
+
+            document.getElementById('startButton').disabled = false;
+            document.getElementById('startButton').value = "Start";
+        }
+    };
+    player.onfinish = (evt) => {
+        const iterTime = parseInt(evt.detail.duration / evt.detail.iterations, 10);
+        message(`${evt.detail.iterations} iterations took ${evt.detail.duration}ms (average ${iterTime}ms / iteration)`);
+
+        document.getElementById('startButton').disabled = false;
+        document.getElementById('startButton').value = "Start";
+    };
+    player.start(realtime);
+}
+
+loadFile().then(enableUI).catch(e => message("Error loading recording: " + e));

VM/novnc/tests/playback.js

@@ -0,0 +1,171 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2018 The noVNC Authors
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ */
+
+import RFB from '../core/rfb.js';
+import * as Log from '../core/util/logging.js';
+
+// Immediate polyfill
+if (window.setImmediate === undefined) {
+    let _immediateIdCounter = 1;
+    const _immediateFuncs = {};
+
+    window.setImmediate = (func) => {
+        const index = _immediateIdCounter++;
+        _immediateFuncs[index] = func;
+        window.postMessage("noVNC immediate trigger:" + index, "*");
+        return index;
+    };
+
+    window.clearImmediate = (id) => {
+        _immediateFuncs[id];
+    };
+
+    window.addEventListener("message", (event) => {
+        if ((typeof event.data !== "string") ||
+            (event.data.indexOf("noVNC immediate trigger:") !== 0)) {
+            return;
+        }
+
+        const index = event.data.slice("noVNC immediate trigger:".length);
+
+        const callback = _immediateFuncs[index];
+        if (callback === undefined) {
+            return;
+        }
+
+        delete _immediateFuncs[index];
+
+        callback();
+    });
+}
+
+class FakeWebSocket {
+    constructor() {
+        this.binaryType = "arraybuffer";
+        this.protocol = "";
+        this.readyState = "open";
+
+        this.onerror = () => {};
+        this.onmessage = () => {};
+        this.onopen = () => {};
+    }
+
+    send() {
+    }
+
+    close() {
+    }
+}
+
+export default class RecordingPlayer {
+    constructor(frames, disconnected) {
+        this._frames = frames;
+
+        this._disconnected = disconnected;
+
+        this._rfb = undefined;
+        this._frameLength = this._frames.length;
+
+        this._frameIndex = 0;
+        this._startTime = undefined;
+        this._realtime = true;
+        this._trafficManagement = true;
+
+        this._running = false;
+
+        this.onfinish = () => {};
+    }
+
+    run(realtime, trafficManagement) {
+        // initialize a new RFB
+        this._ws = new FakeWebSocket();
+        this._rfb = new RFB(document.getElementById('VNC_screen'), this._ws);
+        this._rfb.viewOnly = true;
+        this._rfb.addEventListener("disconnect",
+                                   this._handleDisconnect.bind(this));
+        this._rfb.addEventListener("credentialsrequired",
+                                   this._handleCredentials.bind(this));
+
+        // reset the frame index and timer
+        this._frameIndex = 0;
+        this._startTime = (new Date()).getTime();
+
+        this._realtime = realtime;
+        this._trafficManagement = (trafficManagement === undefined) ? !realtime : trafficManagement;
+
+        this._running = true;
+        this._queueNextPacket();
+    }
+
+    _queueNextPacket() {
+        if (!this._running) { return; }
+
+        let frame = this._frames[this._frameIndex];
+
+        // skip send frames
+        while (this._frameIndex < this._frameLength && frame.fromClient) {
+            this._frameIndex++;
+            frame = this._frames[this._frameIndex];
+        }
+
+        if (this._frameIndex >= this._frameLength) {
+            Log.Debug('Finished, no more frames');
+            this._finish();
+            return;
+        }
+
+        if (this._realtime) {
+            const toffset = (new Date()).getTime() - this._startTime;
+            let delay = frame.timestamp - toffset;
+            if (delay < 1) delay = 1;
+
+            setTimeout(this._doPacket.bind(this), delay);
+        } else {
+            setImmediate(this._doPacket.bind(this));
+        }
+    }
+
+    _doPacket() {
+        // Avoid having excessive queue buildup in non-realtime mode
+        if (this._trafficManagement && this._rfb._flushing) {
+            this._rfb.flush()
+                .then(() => {
+                    this._doPacket();
+                });
+            return;
+        }
+
+        const frame = this._frames[this._frameIndex];
+
+        this._ws.onmessage({'data': frame.data});
+        this._frameIndex++;
+
+        this._queueNextPacket();
+    }
+
+    _finish() {
+        if (this._rfb._display.pending()) {
+            this._rfb._display.flush()
+                .then(() => { this._finish(); });
+        } else {
+            this._running = false;
+            this._ws.onclose({code: 1000, reason: ""});
+            delete this._rfb;
+            this.onfinish((new Date()).getTime() - this._startTime);
+        }
+    }
+
+    _handleDisconnect(evt) {
+        this._running = false;
+        this._disconnected(evt.detail.clean, this._frameIndex);
+    }
+
+    _handleCredentials(evt) {
+        this._rfb.sendCredentials({"username": "Foo",
+                                   "password": "Bar",
+                                   "target": "Baz"});
+    }
+}

VM/novnc/tests/test.base64.js

@@ -0,0 +1,33 @@
+const expect = chai.expect;
+
+import Base64 from '../core/base64.js';
+
+describe('Base64 Tools', function () {
+    "use strict";
+
+    const BIN_ARR = new Array(256);
+    for (let i = 0; i < 256; i++) {
+        BIN_ARR[i] = i;
+    }
+
+    const B64_STR = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==";
+
+
+    describe('encode', function () {
+        it('should encode a binary string into Base64', function () {
+            const encoded = Base64.encode(BIN_ARR);
+            expect(encoded).to.equal(B64_STR);
+        });
+    });
+
+    describe('decode', function () {
+        it('should decode a Base64 string into a normal string', function () {
+            const decoded = Base64.decode(B64_STR);
+            expect(decoded).to.deep.equal(BIN_ARR);
+        });
+
+        it('should throw an error if we have extra characters at the end of the string', function () {
+            expect(() => Base64.decode(B64_STR+'abcdef')).to.throw(Error);
+        });
+    });
+});

VM/novnc/tests/test.browser.js

@@ -0,0 +1,243 @@
+const expect = chai.expect;
+
+import { isMac, isWindows, isIOS, isAndroid, isChromeOS,
+         isSafari, isFirefox, isChrome, isChromium, isOpera, isEdge,
+         isGecko, isWebKit, isBlink } from '../core/util/browser.js';
+
+describe('OS detection', function () {
+    let origNavigator;
+    beforeEach(function () {
+        // window.navigator is a protected read-only property in many
+        // environments, so we need to redefine it whilst running these
+        // tests.
+        origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+        Object.defineProperty(window, "navigator", {value: {}});
+    });
+
+    afterEach(function () {
+        Object.defineProperty(window, "navigator", origNavigator);
+    });
+
+    it('should handle macOS', function () {
+        const platforms = [
+            "MacIntel",
+            "MacPPC",
+        ];
+
+        navigator.userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 12_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6 Safari/605.1.15";
+        platforms.forEach((platform) => {
+            navigator.platform = platform;
+            expect(isMac()).to.be.true;
+            expect(isWindows()).to.be.false;
+            expect(isIOS()).to.be.false;
+            expect(isAndroid()).to.be.false;
+            expect(isChromeOS()).to.be.false;
+        });
+    });
+
+    it('should handle Windows', function () {
+        const platforms = [
+            "Win32",
+            "Win64",
+        ];
+
+        navigator.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36";
+        platforms.forEach((platform) => {
+            navigator.platform = platform;
+            expect(isMac()).to.be.false;
+            expect(isWindows()).to.be.true;
+            expect(isIOS()).to.be.false;
+            expect(isAndroid()).to.be.false;
+            expect(isChromeOS()).to.be.false;
+        });
+    });
+
+    it('should handle iOS', function () {
+        const platforms = [
+            "iPhone",
+            "iPod",
+            "iPad",
+        ];
+
+        navigator.userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Mobile/15E148 Safari/604.1";
+        platforms.forEach((platform) => {
+            navigator.platform = platform;
+            expect(isMac()).to.be.false;
+            expect(isWindows()).to.be.false;
+            expect(isIOS()).to.be.true;
+            expect(isAndroid()).to.be.false;
+            expect(isChromeOS()).to.be.false;
+        });
+    });
+
+    it('should handle Android', function () {
+        let userAgents = [
+            "Mozilla/5.0 (Linux; Android 13; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.5359.128 Mobile Safari/537.36",
+            "Mozilla/5.0 (Android 13; Mobile; LG-M255; rv:108.0) Gecko/108.0 Firefox/108.0",
+        ];
+
+        navigator.platform = "Linux x86_64";
+        userAgents.forEach((ua) => {
+            navigator.userAgent = ua;
+            expect(isMac()).to.be.false;
+            expect(isWindows()).to.be.false;
+            expect(isIOS()).to.be.false;
+            expect(isAndroid()).to.be.true;
+            expect(isChromeOS()).to.be.false;
+        });
+    });
+
+    it('should handle ChromeOS', function () {
+        let userAgents = [
+            "Mozilla/5.0 (X11; CrOS x86_64 15183.59.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.5359.75 Safari/537.36",
+            "Mozilla/5.0 (X11; CrOS aarch64 15183.59.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.5359.75 Safari/537.36",
+        ];
+
+        navigator.platform = "Linux x86_64";
+        userAgents.forEach((ua) => {
+            navigator.userAgent = ua;
+            expect(isMac()).to.be.false;
+            expect(isWindows()).to.be.false;
+            expect(isIOS()).to.be.false;
+            expect(isAndroid()).to.be.false;
+            expect(isChromeOS()).to.be.true;
+        });
+    });
+});
+
+describe('Browser detection', function () {
+    let origNavigator;
+    beforeEach(function () {
+        // window.navigator is a protected read-only property in many
+        // environments, so we need to redefine it whilst running these
+        // tests.
+        origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+        Object.defineProperty(window, "navigator", {value: {}});
+    });
+
+    afterEach(function () {
+        Object.defineProperty(window, "navigator", origNavigator);
+    });
+
+    it('should handle Chrome', function () {
+        navigator.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.true;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.false;
+        expect(isWebKit()).to.be.false;
+        expect(isBlink()).to.be.true;
+    });
+
+    it('should handle Chromium', function () {
+        navigator.userAgent = "Mozilla/5.0 (X11; Linux armv7l) AppleWebKit/537.36 (KHTML, like Gecko) Raspbian Chromium/74.0.3729.157 Chrome/74.0.3729.157 Safari/537.36";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.true;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.false;
+        expect(isWebKit()).to.be.false;
+        expect(isBlink()).to.be.true;
+    });
+
+    it('should handle Firefox', function () {
+        navigator.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:105.0) Gecko/20100101 Firefox/105.0";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.true;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.true;
+        expect(isWebKit()).to.be.false;
+        expect(isBlink()).to.be.false;
+    });
+
+    it('should handle Seamonkey', function () {
+        navigator.userAgent = "Mozilla/5.0 (Windows NT 6.1; rv:36.0) Gecko/20100101 Firefox/36.0 Seamonkey/2.33.1";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.true;
+        expect(isWebKit()).to.be.false;
+        expect(isBlink()).to.be.false;
+    });
+
+    it('should handle Safari', function () {
+        navigator.userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 12_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6 Safari/605.1.15";
+
+        expect(isSafari()).to.be.true;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.false;
+        expect(isWebKit()).to.be.true;
+        expect(isBlink()).to.be.false;
+    });
+
+    it('should handle Edge', function () {
+        navigator.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36 Edg/106.0.1370.34";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.true;
+
+        expect(isGecko()).to.be.false;
+        expect(isWebKit()).to.be.false;
+        expect(isBlink()).to.be.true;
+    });
+
+    it('should handle Opera', function () {
+        navigator.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36 OPR/91.0.4516.20";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.true;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.false;
+        expect(isWebKit()).to.be.false;
+        expect(isBlink()).to.be.true;
+    });
+
+    it('should handle Epiphany', function () {
+        navigator.userAgent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Safari/605.1.15 Epiphany/605.1.15";
+
+        expect(isSafari()).to.be.false;
+        expect(isFirefox()).to.be.false;
+        expect(isChrome()).to.be.false;
+        expect(isChromium()).to.be.false;
+        expect(isOpera()).to.be.false;
+        expect(isEdge()).to.be.false;
+
+        expect(isGecko()).to.be.false;
+        expect(isWebKit()).to.be.true;
+        expect(isBlink()).to.be.false;
+    });
+});

VM/novnc/tests/test.copyrect.js

@@ -0,0 +1,92 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import CopyRectDecoder from '../core/decoders/copyrect.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+describe('CopyRect Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new CopyRectDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle the CopyRect encoding', function () {
+        // seed some initial data to copy
+        display.fillRect(0, 0, 4, 4, [ 0x11, 0x22, 0x33 ]);
+        display.fillRect(0, 0, 2, 2, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done;
+        done = testDecodeRect(decoder, 0, 2, 2, 2,
+                              [0x00, 0x02, 0x00, 0x00],
+                              display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 2, 2, 2,
+                              [0x00, 0x00, 0x00, 0x00],
+                              display, 24);
+        expect(done).to.be.true;
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0,
+                                  [0x00, 0x00, 0x00, 0x00],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+});

VM/novnc/tests/test.deflator.js

@@ -0,0 +1,81 @@
+const expect = chai.expect;
+
+import { inflateInit, inflate } from "../vendor/pako/lib/zlib/inflate.js";
+import ZStream from "../vendor/pako/lib/zlib/zstream.js";
+import Deflator from "../core/deflator.js";
+
+function _inflator(compText, expected) {
+    let strm = new ZStream();
+    let chunkSize = 1024 * 10 * 10;
+    strm.output = new Uint8Array(chunkSize);
+
+    inflateInit(strm, 5);
+
+    if (expected > chunkSize) {
+        chunkSize = expected;
+        strm.output = new Uint8Array(chunkSize);
+    }
+
+    /* eslint-disable camelcase */
+    strm.input = compText;
+    strm.avail_in = strm.input.length;
+    strm.next_in = 0;
+
+    strm.next_out = 0;
+    strm.avail_out = expected.length;
+    /* eslint-enable camelcase */
+
+    let ret = inflate(strm, 0);
+
+    // Check that return code is not an error
+    expect(ret).to.be.greaterThan(-1);
+
+    return new Uint8Array(strm.output.buffer, 0, strm.next_out);
+}
+
+describe('Deflate data', function () {
+
+    it('should be able to deflate messages', function () {
+        let deflator = new Deflator();
+
+        let text = "123asdf";
+        let preText = new Uint8Array(text.length);
+        for (let i = 0; i < preText.length; i++) {
+            preText[i] = text.charCodeAt(i);
+        }
+
+        let compText = deflator.deflate(preText);
+
+        let inflatedText = _inflator(compText, text.length);
+        expect(inflatedText).to.array.equal(preText);
+
+    });
+
+    it('should be able to deflate large messages', function () {
+        let deflator = new Deflator();
+
+        /* Generate a big string with random characters. Used because
+           repetition of letters might be deflated more effectively than
+           random ones. */
+        let text = "";
+        let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < 300000; i++) {
+            text += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+
+        let preText = new Uint8Array(text.length);
+        for (let i = 0; i < preText.length; i++) {
+            preText[i] = text.charCodeAt(i);
+        }
+
+        let compText = deflator.deflate(preText);
+
+        //Check that the compressed size is expected size
+        expect(compText.length).to.be.greaterThan((1024 * 10 * 10) * 2);
+
+        let inflatedText = _inflator(compText, text.length);
+
+        expect(inflatedText).to.array.equal(preText);
+
+    });
+});

VM/novnc/tests/test.display.js

@@ -0,0 +1,395 @@
+const expect = chai.expect;
+
+import Base64 from '../core/base64.js';
+import Display from '../core/display.js';
+
+describe('Display/Canvas Helper', function () {
+    const checkedData = new Uint8ClampedArray([
+        0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+        0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+        0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+        0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+    ]);
+
+    const basicData = new Uint8ClampedArray([0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0xff, 0xff, 0xff, 255]);
+
+    function makeImageCanvas(inputData, width, height) {
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        const data = new ImageData(inputData, width, height);
+        ctx.putImageData(data, 0, 0);
+        return canvas;
+    }
+
+    function makeImagePng(inputData, width, height) {
+        const canvas = makeImageCanvas(inputData, width, height);
+        const url = canvas.toDataURL();
+        const data = url.split(",")[1];
+        return Base64.decode(data);
+    }
+
+    describe('viewport handling', function () {
+        let display;
+        beforeEach(function () {
+            display = new Display(document.createElement('canvas'));
+            display.clipViewport = true;
+            display.resize(5, 5);
+            display.viewportChangeSize(3, 3);
+            display.viewportChangePos(1, 1);
+        });
+
+        it('should take viewport location into consideration when drawing images', function () {
+            display.resize(4, 4);
+            display.viewportChangeSize(2, 2);
+            display.drawImage(makeImageCanvas(basicData, 4, 1), 1, 1);
+            display.flip();
+
+            const expected = new Uint8Array(16);
+            for (let i = 0; i < 8; i++) { expected[i] = basicData[i]; }
+            for (let i = 8; i < 16; i++) { expected[i] = 0; }
+            expect(display).to.have.displayed(expected);
+        });
+
+        it('should resize the target canvas when resizing the viewport', function () {
+            display.viewportChangeSize(2, 2);
+            expect(display._target.width).to.equal(2);
+            expect(display._target.height).to.equal(2);
+        });
+
+        it('should move the viewport if necessary', function () {
+            display.viewportChangeSize(5, 5);
+            expect(display.absX(0)).to.equal(0);
+            expect(display.absY(0)).to.equal(0);
+            expect(display._target.width).to.equal(5);
+            expect(display._target.height).to.equal(5);
+        });
+
+        it('should limit the viewport to the framebuffer size', function () {
+            display.viewportChangeSize(6, 6);
+            expect(display._target.width).to.equal(5);
+            expect(display._target.height).to.equal(5);
+        });
+
+        it('should redraw when moving the viewport', function () {
+            display.flip = sinon.spy();
+            display.viewportChangePos(-1, 1);
+            expect(display.flip).to.have.been.calledOnce;
+        });
+
+        it('should redraw when resizing the viewport', function () {
+            display.flip = sinon.spy();
+            display.viewportChangeSize(2, 2);
+            expect(display.flip).to.have.been.calledOnce;
+        });
+
+        it('should show the entire framebuffer when disabling the viewport', function () {
+            display.clipViewport = false;
+            expect(display.absX(0)).to.equal(0);
+            expect(display.absY(0)).to.equal(0);
+            expect(display._target.width).to.equal(5);
+            expect(display._target.height).to.equal(5);
+        });
+
+        it('should ignore viewport changes when the viewport is disabled', function () {
+            display.clipViewport = false;
+            display.viewportChangeSize(2, 2);
+            display.viewportChangePos(1, 1);
+            expect(display.absX(0)).to.equal(0);
+            expect(display.absY(0)).to.equal(0);
+            expect(display._target.width).to.equal(5);
+            expect(display._target.height).to.equal(5);
+        });
+
+        it('should show the entire framebuffer just after enabling the viewport', function () {
+            display.clipViewport = false;
+            display.clipViewport = true;
+            expect(display.absX(0)).to.equal(0);
+            expect(display.absY(0)).to.equal(0);
+            expect(display._target.width).to.equal(5);
+            expect(display._target.height).to.equal(5);
+        });
+    });
+
+    describe('resizing', function () {
+        let display;
+        beforeEach(function () {
+            display = new Display(document.createElement('canvas'));
+            display.clipViewport = false;
+            display.resize(4, 4);
+        });
+
+        it('should change the size of the logical canvas', function () {
+            display.resize(5, 7);
+            expect(display._fbWidth).to.equal(5);
+            expect(display._fbHeight).to.equal(7);
+        });
+
+        it('should keep the framebuffer data', function () {
+            display.fillRect(0, 0, 4, 4, [0xff, 0, 0]);
+            display.resize(2, 2);
+            display.flip();
+            const expected = [];
+            for (let i = 0; i < 4 * 2*2; i += 4) {
+                expected[i] = 0xff;
+                expected[i+1] = expected[i+2] = 0;
+                expected[i+3] = 0xff;
+            }
+            expect(display).to.have.displayed(new Uint8Array(expected));
+        });
+
+        describe('viewport', function () {
+            beforeEach(function () {
+                display.clipViewport = true;
+                display.viewportChangeSize(3, 3);
+                display.viewportChangePos(1, 1);
+            });
+
+            it('should keep the viewport position and size if possible', function () {
+                display.resize(6, 6);
+                expect(display.absX(0)).to.equal(1);
+                expect(display.absY(0)).to.equal(1);
+                expect(display._target.width).to.equal(3);
+                expect(display._target.height).to.equal(3);
+            });
+
+            it('should move the viewport if necessary', function () {
+                display.resize(3, 3);
+                expect(display.absX(0)).to.equal(0);
+                expect(display.absY(0)).to.equal(0);
+                expect(display._target.width).to.equal(3);
+                expect(display._target.height).to.equal(3);
+            });
+
+            it('should shrink the viewport if necessary', function () {
+                display.resize(2, 2);
+                expect(display.absX(0)).to.equal(0);
+                expect(display.absY(0)).to.equal(0);
+                expect(display._target.width).to.equal(2);
+                expect(display._target.height).to.equal(2);
+            });
+        });
+    });
+
+    describe('rescaling', function () {
+        let display;
+        let canvas;
+
+        beforeEach(function () {
+            canvas = document.createElement('canvas');
+            display = new Display(canvas);
+            display.clipViewport = true;
+            display.resize(4, 4);
+            display.viewportChangeSize(3, 3);
+            display.viewportChangePos(1, 1);
+            document.body.appendChild(canvas);
+        });
+
+        afterEach(function () {
+            document.body.removeChild(canvas);
+        });
+
+        it('should not change the bitmap size of the canvas', function () {
+            display.scale = 2.0;
+            expect(canvas.width).to.equal(3);
+            expect(canvas.height).to.equal(3);
+        });
+
+        it('should change the effective rendered size of the canvas', function () {
+            display.scale = 2.0;
+            expect(canvas.clientWidth).to.equal(6);
+            expect(canvas.clientHeight).to.equal(6);
+        });
+
+        it('should not change when resizing', function () {
+            display.scale = 2.0;
+            display.resize(5, 5);
+            expect(display.scale).to.equal(2.0);
+            expect(canvas.width).to.equal(3);
+            expect(canvas.height).to.equal(3);
+            expect(canvas.clientWidth).to.equal(6);
+            expect(canvas.clientHeight).to.equal(6);
+        });
+    });
+
+    describe('autoscaling', function () {
+        let display;
+        let canvas;
+
+        beforeEach(function () {
+            canvas = document.createElement('canvas');
+            display = new Display(canvas);
+            display.clipViewport = true;
+            display.resize(4, 3);
+            display.viewportChangeSize(4, 3);
+            document.body.appendChild(canvas);
+        });
+
+        afterEach(function () {
+            document.body.removeChild(canvas);
+        });
+
+        it('should preserve aspect ratio while autoscaling', function () {
+            display.autoscale(16, 9);
+            expect(canvas.clientWidth / canvas.clientHeight).to.equal(4 / 3);
+        });
+
+        it('should use width to determine scale when the current aspect ratio is wider than the target', function () {
+            display.autoscale(9, 16);
+            expect(display.absX(9)).to.equal(4);
+            expect(display.absY(18)).to.equal(8);
+            expect(canvas.clientWidth).to.equal(9);
+            expect(canvas.clientHeight).to.equal(7); // round 9 / (4 / 3)
+        });
+
+        it('should use height to determine scale when the current aspect ratio is taller than the target', function () {
+            display.autoscale(16, 9);
+            expect(display.absX(9)).to.equal(3);
+            expect(display.absY(18)).to.equal(6);
+            expect(canvas.clientWidth).to.equal(12);  // 16 * (4 / 3)
+            expect(canvas.clientHeight).to.equal(9);
+
+        });
+
+        it('should not change the bitmap size of the canvas', function () {
+            display.autoscale(16, 9);
+            expect(canvas.width).to.equal(4);
+            expect(canvas.height).to.equal(3);
+        });
+    });
+
+    describe('drawing', function () {
+
+        // TODO(directxman12): improve the tests for each of the drawing functions to cover more than just the
+        //                     basic cases
+        let display;
+        beforeEach(function () {
+            display = new Display(document.createElement('canvas'));
+            display.resize(4, 4);
+        });
+
+        it('should not draw directly on the target canvas', function () {
+            display.fillRect(0, 0, 4, 4, [0xff, 0, 0]);
+            display.flip();
+            display.fillRect(0, 0, 4, 4, [0, 0xff, 0]);
+            const expected = [];
+            for (let i = 0; i < 4 * display._fbWidth * display._fbHeight; i += 4) {
+                expected[i] = 0xff;
+                expected[i+1] = expected[i+2] = 0;
+                expected[i+3] = 0xff;
+            }
+            expect(display).to.have.displayed(new Uint8Array(expected));
+        });
+
+        it('should support filling a rectangle with particular color via #fillRect', function () {
+            display.fillRect(0, 0, 4, 4, [0, 0xff, 0]);
+            display.fillRect(0, 0, 2, 2, [0, 0, 0xff]);
+            display.fillRect(2, 2, 2, 2, [0, 0, 0xff]);
+            display.flip();
+            expect(display).to.have.displayed(checkedData);
+        });
+
+        it('should support copying an portion of the canvas via #copyImage', function () {
+            display.fillRect(0, 0, 4, 4, [0, 0xff, 0]);
+            display.fillRect(0, 0, 2, 2, [0, 0, 0xff]);
+            display.copyImage(0, 0, 2, 2, 2, 2);
+            display.flip();
+            expect(display).to.have.displayed(checkedData);
+        });
+
+        it('should support drawing images via #imageRect', async function () {
+            display.imageRect(0, 0, 4, 4, "image/png", makeImagePng(checkedData, 4, 4));
+            display.flip();
+            await display.flush();
+            expect(display).to.have.displayed(checkedData);
+        });
+
+        it('should support blit images with true color via #blitImage', function () {
+            display.blitImage(0, 0, 4, 4, checkedData, 0);
+            display.flip();
+            expect(display).to.have.displayed(checkedData);
+        });
+
+        it('should support drawing an image object via #drawImage', function () {
+            const img = makeImageCanvas(checkedData, 4, 4);
+            display.drawImage(img, 0, 0);
+            display.flip();
+            expect(display).to.have.displayed(checkedData);
+        });
+    });
+
+    describe('the render queue processor', function () {
+        let display;
+        beforeEach(function () {
+            display = new Display(document.createElement('canvas'));
+            display.resize(4, 4);
+            sinon.spy(display, '_scanRenderQ');
+        });
+
+        it('should try to process an item when it is pushed on, if nothing else is on the queue', function () {
+            display._renderQPush({ type: 'noop' });  // does nothing
+            expect(display._scanRenderQ).to.have.been.calledOnce;
+        });
+
+        it('should not try to process an item when it is pushed on if we are waiting for other items', function () {
+            display._renderQ.length = 2;
+            display._renderQPush({ type: 'noop' });
+            expect(display._scanRenderQ).to.not.have.been.called;
+        });
+
+        it('should wait until an image is loaded to attempt to draw it and the rest of the queue', function () {
+            const img = { complete: false, width: 4, height: 4, addEventListener: sinon.spy() };
+            display._renderQ = [{ type: 'img', x: 3, y: 4, width: 4, height: 4, img: img },
+                                { type: 'fill', x: 1, y: 2, width: 3, height: 4, color: 5 }];
+            display.drawImage = sinon.spy();
+            display.fillRect = sinon.spy();
+
+            display._scanRenderQ();
+            expect(display.drawImage).to.not.have.been.called;
+            expect(display.fillRect).to.not.have.been.called;
+            expect(img.addEventListener).to.have.been.calledOnce;
+
+            display._renderQ[0].img.complete = true;
+            display._scanRenderQ();
+            expect(display.drawImage).to.have.been.calledOnce;
+            expect(display.fillRect).to.have.been.calledOnce;
+            expect(img.addEventListener).to.have.been.calledOnce;
+        });
+
+        it('should resolve promise when queue is flushed', async function () {
+            display.fillRect(0, 0, 4, 4, [0, 0xff, 0]);
+            let promise = display.flush();
+            expect(promise).to.be.an.instanceOf(Promise);
+            await promise;
+        });
+
+        it('should draw a blit image on type "blit"', function () {
+            display.blitImage = sinon.spy();
+            display._renderQPush({ type: 'blit', x: 3, y: 4, width: 5, height: 6, data: [7, 8, 9] });
+            expect(display.blitImage).to.have.been.calledOnce;
+            expect(display.blitImage).to.have.been.calledWith(3, 4, 5, 6, [7, 8, 9], 0);
+        });
+
+        it('should copy a region on type "copy"', function () {
+            display.copyImage = sinon.spy();
+            display._renderQPush({ type: 'copy', x: 3, y: 4, width: 5, height: 6, oldX: 7, oldY: 8 });
+            expect(display.copyImage).to.have.been.calledOnce;
+            expect(display.copyImage).to.have.been.calledWith(7, 8, 3, 4, 5, 6);
+        });
+
+        it('should fill a rect with a given color on type "fill"', function () {
+            display.fillRect = sinon.spy();
+            display._renderQPush({ type: 'fill', x: 3, y: 4, width: 5, height: 6, color: [7, 8, 9]});
+            expect(display.fillRect).to.have.been.calledOnce;
+            expect(display.fillRect).to.have.been.calledWith(3, 4, 5, 6, [7, 8, 9]);
+        });
+
+        it('should draw an image from an image object on type "img" (if complete)', function () {
+            display.drawImage = sinon.spy();
+            display._renderQPush({ type: 'img', x: 3, y: 4, img: { complete: true } });
+            expect(display.drawImage).to.have.been.calledOnce;
+            expect(display.drawImage).to.have.been.calledWith({ complete: true }, 3, 4);
+        });
+    });
+});

VM/novnc/tests/test.helper.js

@@ -0,0 +1,209 @@
+const expect = chai.expect;
+
+import keysyms from '../core/input/keysymdef.js';
+import * as KeyboardUtil from "../core/input/util.js";
+
+describe('Helpers', function () {
+    "use strict";
+
+    describe('keysyms.lookup', function () {
+        it('should map ASCII characters to keysyms', function () {
+            expect(keysyms.lookup('a'.charCodeAt())).to.be.equal(0x61);
+            expect(keysyms.lookup('A'.charCodeAt())).to.be.equal(0x41);
+        });
+        it('should map Latin-1 characters to keysyms', function () {
+            expect(keysyms.lookup('ø'.charCodeAt())).to.be.equal(0xf8);
+
+            expect(keysyms.lookup('é'.charCodeAt())).to.be.equal(0xe9);
+        });
+        it('should map characters that are in Windows-1252 but not in Latin-1 to keysyms', function () {
+            expect(keysyms.lookup('Š'.charCodeAt())).to.be.equal(0x01a9);
+        });
+        it('should map characters which aren\'t in Latin1 *or* Windows-1252 to keysyms', function () {
+            expect(keysyms.lookup('ũ'.charCodeAt())).to.be.equal(0x03fd);
+        });
+        it('should map unknown codepoints to the Unicode range', function () {
+            expect(keysyms.lookup('\n'.charCodeAt())).to.be.equal(0x100000a);
+            expect(keysyms.lookup('\u262D'.charCodeAt())).to.be.equal(0x100262d);
+        });
+        // This requires very recent versions of most browsers... skipping for now
+        it.skip('should map UCS-4 codepoints to the Unicode range', function () {
+            //expect(keysyms.lookup('\u{1F686}'.codePointAt())).to.be.equal(0x101f686);
+        });
+    });
+
+    describe('getKeycode', function () {
+        it('should pass through proper code', function () {
+            expect(KeyboardUtil.getKeycode({code: 'Semicolon'})).to.be.equal('Semicolon');
+        });
+        it('should map legacy values', function () {
+            expect(KeyboardUtil.getKeycode({code: ''})).to.be.equal('Unidentified');
+            expect(KeyboardUtil.getKeycode({code: 'OSLeft'})).to.be.equal('MetaLeft');
+        });
+        it('should map keyCode to code when possible', function () {
+            expect(KeyboardUtil.getKeycode({keyCode: 0x14})).to.be.equal('CapsLock');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x5b})).to.be.equal('MetaLeft');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x35})).to.be.equal('Digit5');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x65})).to.be.equal('Numpad5');
+        });
+        it('should map keyCode left/right side', function () {
+            expect(KeyboardUtil.getKeycode({keyCode: 0x10, location: 1})).to.be.equal('ShiftLeft');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x10, location: 2})).to.be.equal('ShiftRight');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x11, location: 1})).to.be.equal('ControlLeft');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x11, location: 2})).to.be.equal('ControlRight');
+        });
+        it('should map keyCode on numpad', function () {
+            expect(KeyboardUtil.getKeycode({keyCode: 0x0d, location: 0})).to.be.equal('Enter');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x0d, location: 3})).to.be.equal('NumpadEnter');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x23, location: 0})).to.be.equal('End');
+            expect(KeyboardUtil.getKeycode({keyCode: 0x23, location: 3})).to.be.equal('Numpad1');
+        });
+        it('should return Unidentified when it cannot map the keyCode', function () {
+            expect(KeyboardUtil.getKeycode({keycode: 0x42})).to.be.equal('Unidentified');
+        });
+
+        describe('Fix Meta on macOS', function () {
+            let origNavigator;
+            beforeEach(function () {
+                // window.navigator is a protected read-only property in many
+                // environments, so we need to redefine it whilst running these
+                // tests.
+                origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+                Object.defineProperty(window, "navigator", {value: {}});
+                window.navigator.platform = "Mac x86_64";
+            });
+            afterEach(function () {
+                Object.defineProperty(window, "navigator", origNavigator);
+            });
+
+            it('should respect ContextMenu on modern browser', function () {
+                expect(KeyboardUtil.getKeycode({code: 'ContextMenu', keyCode: 0x5d})).to.be.equal('ContextMenu');
+            });
+            it('should translate legacy ContextMenu to MetaRight', function () {
+                expect(KeyboardUtil.getKeycode({keyCode: 0x5d})).to.be.equal('MetaRight');
+            });
+        });
+    });
+
+    describe('getKey', function () {
+        it('should prefer key', function () {
+            expect(KeyboardUtil.getKey({key: 'a', charCode: 'Š'.charCodeAt(), keyCode: 0x42, which: 0x43})).to.be.equal('a');
+        });
+        it('should map legacy values', function () {
+            expect(KeyboardUtil.getKey({key: 'OS'})).to.be.equal('Meta');
+            expect(KeyboardUtil.getKey({key: 'UIKeyInputLeftArrow'})).to.be.equal('ArrowLeft');
+        });
+        it('should handle broken Delete', function () {
+            expect(KeyboardUtil.getKey({key: '\x00', code: 'NumpadDecimal'})).to.be.equal('Delete');
+        });
+        it('should use code if no key', function () {
+            expect(KeyboardUtil.getKey({code: 'NumpadBackspace'})).to.be.equal('Backspace');
+        });
+        it('should not use code fallback for character keys', function () {
+            expect(KeyboardUtil.getKey({code: 'KeyA'})).to.be.equal('Unidentified');
+            expect(KeyboardUtil.getKey({code: 'Digit1'})).to.be.equal('Unidentified');
+            expect(KeyboardUtil.getKey({code: 'Period'})).to.be.equal('Unidentified');
+            expect(KeyboardUtil.getKey({code: 'Numpad1'})).to.be.equal('Unidentified');
+        });
+        it('should use charCode if no key', function () {
+            expect(KeyboardUtil.getKey({charCode: 'Š'.charCodeAt(), keyCode: 0x42, which: 0x43})).to.be.equal('Š');
+            // Broken Oculus browser
+            expect(KeyboardUtil.getKey({charCode: 'Š'.charCodeAt(), keyCode: 0x42, which: 0x43, key: 'Unidentified'})).to.be.equal('Š');
+        });
+        it('should return Unidentified when it cannot map the key', function () {
+            expect(KeyboardUtil.getKey({keycode: 0x42})).to.be.equal('Unidentified');
+        });
+    });
+
+    describe('getKeysym', function () {
+        describe('Non-character keys', function () {
+            it('should recognize the right keys', function () {
+                expect(KeyboardUtil.getKeysym({key: 'Enter'})).to.be.equal(0xFF0D);
+                expect(KeyboardUtil.getKeysym({key: 'Backspace'})).to.be.equal(0xFF08);
+                expect(KeyboardUtil.getKeysym({key: 'Tab'})).to.be.equal(0xFF09);
+                expect(KeyboardUtil.getKeysym({key: 'Shift'})).to.be.equal(0xFFE1);
+                expect(KeyboardUtil.getKeysym({key: 'Control'})).to.be.equal(0xFFE3);
+                expect(KeyboardUtil.getKeysym({key: 'Alt'})).to.be.equal(0xFFE9);
+                expect(KeyboardUtil.getKeysym({key: 'Meta'})).to.be.equal(0xFFEB);
+                expect(KeyboardUtil.getKeysym({key: 'Escape'})).to.be.equal(0xFF1B);
+                expect(KeyboardUtil.getKeysym({key: 'ArrowUp'})).to.be.equal(0xFF52);
+            });
+            it('should map left/right side', function () {
+                expect(KeyboardUtil.getKeysym({key: 'Shift', location: 1})).to.be.equal(0xFFE1);
+                expect(KeyboardUtil.getKeysym({key: 'Shift', location: 2})).to.be.equal(0xFFE2);
+                expect(KeyboardUtil.getKeysym({key: 'Control', location: 1})).to.be.equal(0xFFE3);
+                expect(KeyboardUtil.getKeysym({key: 'Control', location: 2})).to.be.equal(0xFFE4);
+            });
+            it('should handle AltGraph', function () {
+                expect(KeyboardUtil.getKeysym({code: 'AltRight', key: 'Alt', location: 2})).to.be.equal(0xFFEA);
+                expect(KeyboardUtil.getKeysym({code: 'AltRight', key: 'AltGraph', location: 2})).to.be.equal(0xFE03);
+            });
+            it('should handle Windows key with incorrect location', function () {
+                expect(KeyboardUtil.getKeysym({key: 'Meta', location: 0})).to.be.equal(0xFFEC);
+            });
+            it('should handle Clear/NumLock key with incorrect location', function () {
+                this.skip(); // Broken because of Clear/NumLock override
+                expect(KeyboardUtil.getKeysym({key: 'Clear', code: 'NumLock', location: 3})).to.be.equal(0xFF0B);
+            });
+            it('should handle Meta/Windows distinction', function () {
+                expect(KeyboardUtil.getKeysym({code: 'AltLeft', key: 'Meta', location: 1})).to.be.equal(0xFFE7);
+                expect(KeyboardUtil.getKeysym({code: 'AltRight', key: 'Meta', location: 2})).to.be.equal(0xFFE8);
+                expect(KeyboardUtil.getKeysym({code: 'MetaLeft', key: 'Meta', location: 1})).to.be.equal(0xFFEB);
+                expect(KeyboardUtil.getKeysym({code: 'MetaRight', key: 'Meta', location: 2})).to.be.equal(0xFFEC);
+            });
+            it('should send NumLock even if key is Clear', function () {
+                expect(KeyboardUtil.getKeysym({key: 'Clear', code: 'NumLock'})).to.be.equal(0xFF7F);
+            });
+            it('should return null for unknown keys', function () {
+                expect(KeyboardUtil.getKeysym({key: 'Semicolon'})).to.be.null;
+                expect(KeyboardUtil.getKeysym({key: 'BracketRight'})).to.be.null;
+            });
+            it('should handle remappings', function () {
+                expect(KeyboardUtil.getKeysym({code: 'ControlLeft', key: 'Tab'})).to.be.equal(0xFF09);
+            });
+        });
+
+        describe('Numpad', function () {
+            it('should handle Numpad numbers', function () {
+                expect(KeyboardUtil.getKeysym({code: 'Digit5', key: '5', location: 0})).to.be.equal(0x0035);
+                expect(KeyboardUtil.getKeysym({code: 'Numpad5', key: '5', location: 3})).to.be.equal(0xFFB5);
+            });
+            it('should handle Numpad non-character keys', function () {
+                expect(KeyboardUtil.getKeysym({code: 'Home', key: 'Home', location: 0})).to.be.equal(0xFF50);
+                expect(KeyboardUtil.getKeysym({code: 'Numpad5', key: 'Home', location: 3})).to.be.equal(0xFF95);
+                expect(KeyboardUtil.getKeysym({code: 'Delete', key: 'Delete', location: 0})).to.be.equal(0xFFFF);
+                expect(KeyboardUtil.getKeysym({code: 'NumpadDecimal', key: 'Delete', location: 3})).to.be.equal(0xFF9F);
+            });
+            it('should handle Numpad Decimal key', function () {
+                expect(KeyboardUtil.getKeysym({code: 'NumpadDecimal', key: '.', location: 3})).to.be.equal(0xFFAE);
+                expect(KeyboardUtil.getKeysym({code: 'NumpadDecimal', key: ',', location: 3})).to.be.equal(0xFFAC);
+            });
+        });
+
+        describe('Japanese IM keys on Windows', function () {
+            let origNavigator;
+            beforeEach(function () {
+                // window.navigator is a protected read-only property in many
+                // environments, so we need to redefine it whilst running these
+                // tests.
+                origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+                Object.defineProperty(window, "navigator", {value: {}});
+                window.navigator.platform = "Windows";
+            });
+
+            afterEach(function () {
+                Object.defineProperty(window, "navigator", origNavigator);
+            });
+
+            const keys = { 'Zenkaku': 0xff2a, 'Hankaku': 0xff2a,
+                           'Romaji': 0xff24, 'KanaMode': 0xff24 };
+            for (let [key, keysym] of Object.entries(keys)) {
+                it(`should fake combined key for ${key} on Windows`, function () {
+                    expect(KeyboardUtil.getKeysym({code: 'FakeIM', key: key})).to.be.equal(keysym);
+                });
+            }
+        });
+    });
+});

VM/novnc/tests/test.hextile.js

@@ -0,0 +1,242 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import HextileDecoder from '../core/decoders/hextile.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+function push32(arr, num) {
+    arr.push((num >> 24) & 0xFF,
+             (num >> 16) & 0xFF,
+             (num >>  8) & 0xFF,
+             num & 0xFF);
+}
+
+describe('Hextile Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new HextileDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle a tile with fg, bg specified, normal subrects', function () {
+        let data = [];
+        data.push(0x02 | 0x04 | 0x08); // bg spec, fg spec, anysubrects
+        push32(data, 0x00ff0000); // becomes 00ff0000 --> #00FF00 bg color
+        data.push(0x00); // becomes 0000ff00 --> #0000FF fg color
+        data.push(0x00);
+        data.push(0xff);
+        data.push(0x00);
+        data.push(2); // 2 subrects
+        data.push(0); // x: 0, y: 0
+        data.push(1 | (1 << 4)); // width: 2, height: 2
+        data.push(2 | (2 << 4)); // x: 2, y: 2
+        data.push(1 | (1 << 4)); // width: 2, height: 2
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle a raw tile', function () {
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        let data = [];
+        data.push(0x01); // raw
+        for (let i = 0; i < targetData.length; i += 4) {
+            data.push(targetData[i]);
+            data.push(targetData[i + 1]);
+            data.push(targetData[i + 2]);
+            // Last byte zero to test correct alpha handling
+            data.push(0);
+        }
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle a tile with only bg specified (solid bg)', function () {
+        let data = [];
+        data.push(0x02);
+        push32(data, 0x00ff0000); // becomes 00ff0000 --> #00FF00 bg color
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let expected = [];
+        for (let i = 0; i < 16; i++) {
+            push32(expected, 0x00ff00ff);
+        }
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(new Uint8Array(expected));
+    });
+
+    it('should handle a tile with only bg specified and an empty frame afterwards', function () {
+        // set the width so we can have two tiles
+        display.resize(8, 4);
+
+        let data = [];
+
+        // send a bg frame
+        data.push(0x02);
+        push32(data, 0x00ff0000); // becomes 00ff0000 --> #00FF00 bg color
+
+        // send an empty frame
+        data.push(0x00);
+
+        let done = testDecodeRect(decoder, 0, 0, 32, 4, data, display, 24);
+
+        let expected = [];
+        for (let i = 0; i < 16; i++) {
+            push32(expected, 0x00ff00ff);     // rect 1: solid
+        }
+        for (let i = 0; i < 16; i++) {
+            push32(expected, 0x00ff00ff);    // rect 2: same bkground color
+        }
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(new Uint8Array(expected));
+    });
+
+    it('should handle a tile with bg and coloured subrects', function () {
+        let data = [];
+        data.push(0x02 | 0x08 | 0x10); // bg spec, anysubrects, colouredsubrects
+        push32(data, 0x00ff0000); // becomes 00ff0000 --> #00FF00 bg color
+        data.push(2); // 2 subrects
+        data.push(0x00); // becomes 0000ff00 --> #0000FF fg color
+        data.push(0x00);
+        data.push(0xff);
+        data.push(0x00);
+        data.push(0); // x: 0, y: 0
+        data.push(1 | (1 << 4)); // width: 2, height: 2
+        data.push(0x00); // becomes 0000ff00 --> #0000FF fg color
+        data.push(0x00);
+        data.push(0xff);
+        data.push(0x00);
+        data.push(2 | (2 << 4)); // x: 2, y: 2
+        data.push(1 | (1 << 4)); // width: 2, height: 2
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should carry over fg and bg colors from the previous tile if not specified', function () {
+        display.resize(4, 17);
+
+        let data = [];
+        data.push(0x02 | 0x04 | 0x08); // bg spec, fg spec, anysubrects
+        push32(data, 0xff00ff); // becomes 00ff00ff --> #00FF00 bg color
+        data.push(0x00); // becomes 0000ffff --> #0000FF fg color
+        data.push(0x00);
+        data.push(0xff);
+        data.push(0xff);
+        data.push(8); // 8 subrects
+        for (let i = 0; i < 4; i++) {
+            data.push((0 << 4) | (i * 4)); // x: 0, y: i*4
+            data.push(1 | (1 << 4)); // width: 2, height: 2
+            data.push((2 << 4) | (i * 4 + 2)); // x: 2, y: i * 4 + 2
+            data.push(1 | (1 << 4)); // width: 2, height: 2
+        }
+        data.push(0x08); // anysubrects
+        data.push(1); // 1 subrect
+        data.push(0); // x: 0, y: 0
+        data.push(1 | (1 << 4)); // width: 2, height: 2
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 17, data, display, 24);
+
+        let targetData = [
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ];
+
+        let expected = [];
+        for (let i = 0; i < 4; i++) {
+            expected = expected.concat(targetData);
+        }
+        expected = expected.concat(targetData.slice(0, 16));
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(new Uint8Array(expected));
+    });
+
+    it('should fail on an invalid subencoding', function () {
+        let data = [45];  // an invalid subencoding
+        expect(() => testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24)).to.throw();
+    });
+
+    it('should handle empty rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0, [], display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+});

VM/novnc/tests/test.inflator.js

@@ -0,0 +1,112 @@
+const expect = chai.expect;
+
+import { deflateInit, deflate, Z_FULL_FLUSH } from "../vendor/pako/lib/zlib/deflate.js";
+import ZStream from "../vendor/pako/lib/zlib/zstream.js";
+import Inflator from "../core/inflator.js";
+
+function _deflator(data) {
+    let strm = new ZStream();
+
+    deflateInit(strm, 5);
+
+    /* eslint-disable camelcase */
+    strm.input = data;
+    strm.avail_in = strm.input.length;
+    strm.next_in = 0;
+    /* eslint-enable camelcase */
+
+    let chunks = [];
+    let totalLen = 0;
+    while (strm.avail_in > 0) {
+        /* eslint-disable camelcase */
+        strm.output = new Uint8Array(1024 * 10 * 10);
+        strm.avail_out = strm.output.length;
+        strm.next_out = 0;
+        /* eslint-enable camelcase */
+
+        let ret = deflate(strm, Z_FULL_FLUSH);
+
+        // Check that return code is not an error
+        expect(ret).to.be.greaterThan(-1);
+
+        let chunk = new Uint8Array(strm.output.buffer, 0, strm.next_out);
+        totalLen += chunk.length;
+        chunks.push(chunk);
+    }
+
+    // Combine chunks into a single data
+
+    let outData = new Uint8Array(totalLen);
+    let offset = 0;
+
+    for (let i = 0; i < chunks.length; i++) {
+        outData.set(chunks[i], offset);
+        offset += chunks[i].length;
+    }
+
+    return outData;
+}
+
+describe('Inflate data', function () {
+
+    it('should be able to inflate messages', function () {
+        let inflator = new Inflator();
+
+        let text = "123asdf";
+        let preText = new Uint8Array(text.length);
+        for (let i = 0; i < preText.length; i++) {
+            preText[i] = text.charCodeAt(i);
+        }
+
+        let compText = _deflator(preText);
+
+        inflator.setInput(compText);
+        let inflatedText = inflator.inflate(preText.length);
+
+        expect(inflatedText).to.array.equal(preText);
+
+    });
+
+    it('should be able to inflate large messages', function () {
+        let inflator = new Inflator();
+
+        /* Generate a big string with random characters. Used because
+           repetition of letters might be deflated more effectively than
+           random ones. */
+        let text = "";
+        let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < 300000; i++) {
+            text += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+
+        let preText = new Uint8Array(text.length);
+        for (let i = 0; i < preText.length; i++) {
+            preText[i] = text.charCodeAt(i);
+        }
+
+        let compText = _deflator(preText);
+
+        //Check that the compressed size is expected size
+        expect(compText.length).to.be.greaterThan((1024 * 10 * 10) * 2);
+
+        inflator.setInput(compText);
+        let inflatedText = inflator.inflate(preText.length);
+
+        expect(inflatedText).to.array.equal(preText);
+    });
+
+    it('should throw an error on insufficient data', function () {
+        let inflator = new Inflator();
+
+        let text = "123asdf";
+        let preText = new Uint8Array(text.length);
+        for (let i = 0; i < preText.length; i++) {
+            preText[i] = text.charCodeAt(i);
+        }
+
+        let compText = _deflator(preText);
+
+        inflator.setInput(compText);
+        expect(() => inflator.inflate(preText.length * 2)).to.throw();
+    });
+});

VM/novnc/tests/test.int.js

@@ -0,0 +1,15 @@
+const expect = chai.expect;
+
+import { toUnsigned32bit, toSigned32bit } from '../core/util/int.js';
+
+describe('Integer casting', function () {
+    it('should cast unsigned to signed', function () {
+        let expected = 4294967286;
+        expect(toUnsigned32bit(-10)).to.equal(expected);
+    });
+
+    it('should cast signed to unsigned', function () {
+        let expected = -10;
+        expect(toSigned32bit(4294967286)).to.equal(expected);
+    });
+});

VM/novnc/tests/test.jpeg.js

@@ -0,0 +1,292 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import JPEGDecoder from '../core/decoders/jpeg.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+describe('JPEG Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new JPEGDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle JPEG rects', async function () {
+        let data = [
+            // JPEG data
+            0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46,
+            0x49, 0x46, 0x00, 0x01, 0x01, 0x01, 0x01, 0x2c,
+            0x01, 0x2c, 0x00, 0x42, 0xff, 0xdb, 0x00, 0x43,
+            0x00, 0x03, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03,
+            0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x04, 0x05,
+            0x08, 0x05, 0x05, 0x04, 0x04, 0x05, 0x0a, 0x07,
+            0x07, 0x06, 0x08, 0x0c, 0x0a, 0x0c, 0x0c, 0x0b,
+            0x0a, 0x0b, 0x0b, 0x0d, 0x0e, 0x12, 0x10, 0x0d,
+            0x0e, 0x11, 0x0e, 0x0b, 0x0b, 0x10, 0x16, 0x10,
+            0x11, 0x13, 0x14, 0x15, 0x15, 0x15, 0x0c, 0x0f,
+            0x17, 0x18, 0x16, 0x14, 0x18, 0x12, 0x14, 0x15,
+            0x14, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x03, 0x04,
+            0x04, 0x05, 0x04, 0x05, 0x09, 0x05, 0x05, 0x09,
+            0x14, 0x0d, 0x0b, 0x0d, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xff, 0xc0,
+            0x00, 0x11, 0x08, 0x00, 0x04, 0x00, 0x04, 0x03,
+            0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11,
+            0x01, 0xff, 0xc4, 0x00, 0x1f, 0x00, 0x00, 0x01,
+            0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+            0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+            0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00,
+            0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05,
+            0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d, 0x01,
+            0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21,
+            0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22,
+            0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23,
+            0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24,
+            0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17,
+            0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29,
+            0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a,
+            0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
+            0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+            0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+            0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+            0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+            0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+            0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,
+            0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+            0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6,
+            0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5,
+            0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3,
+            0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
+            0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+            0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01, 0x00, 0x03,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+            0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+            0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00,
+            0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07,
+            0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00,
+            0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+            0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13,
+            0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1,
+            0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15,
+            0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1,
+            0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27,
+            0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39,
+            0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+            0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+            0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+            0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+            0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
+            0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+            0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
+            0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5,
+            0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4,
+            0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
+            0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2,
+            0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+            0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+            0xfa, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00,
+            0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf9,
+            0xf7, 0xfb, 0x67, 0x56, 0xff, 0x00, 0x9f, 0xf8,
+            0x3f, 0xf0, 0x51, 0xa7, 0xff, 0x00, 0xf2, 0x3d,
+            0x7e, 0x6f, 0xfd, 0xab, 0x94, 0x7f, 0xd0, 0x9a,
+            0x8f, 0xfe, 0x0d, 0xc7, 0x7f, 0xf3, 0x61, 0xfd,
+            0xa7, 0xff, 0x00, 0x10, 0x77, 0x0d, 0xff, 0x00,
+            0x43, 0xec, 0xcf, 0xff, 0x00, 0x0b, 0xab, 0x1f,
+            0xff, 0xd9,
+        ];
+
+        let decodeDone = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+        expect(decodeDone).to.be.true;
+
+        let targetData = new Uint8Array([
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255
+        ]);
+
+        // Browsers have rounding errors, so we need an approximate
+        // comparing function
+        function almost(a, b) {
+            let diff = Math.abs(a - b);
+            return diff < 5;
+        }
+
+        await display.flush();
+        expect(display).to.have.displayed(targetData, almost);
+    });
+
+    it('should handle JPEG rects without Huffman and quantification tables', async function () {
+        let data1 = [
+            // JPEG data
+            0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46,
+            0x49, 0x46, 0x00, 0x01, 0x01, 0x01, 0x01, 0x2c,
+            0x01, 0x2c, 0x00, 0x42, 0xff, 0xdb, 0x00, 0x43,
+            0x00, 0x03, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03,
+            0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x04, 0x05,
+            0x08, 0x05, 0x05, 0x04, 0x04, 0x05, 0x0a, 0x07,
+            0x07, 0x06, 0x08, 0x0c, 0x0a, 0x0c, 0x0c, 0x0b,
+            0x0a, 0x0b, 0x0b, 0x0d, 0x0e, 0x12, 0x10, 0x0d,
+            0x0e, 0x11, 0x0e, 0x0b, 0x0b, 0x10, 0x16, 0x10,
+            0x11, 0x13, 0x14, 0x15, 0x15, 0x15, 0x0c, 0x0f,
+            0x17, 0x18, 0x16, 0x14, 0x18, 0x12, 0x14, 0x15,
+            0x14, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x03, 0x04,
+            0x04, 0x05, 0x04, 0x05, 0x09, 0x05, 0x05, 0x09,
+            0x14, 0x0d, 0x0b, 0x0d, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+            0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xff, 0xc0,
+            0x00, 0x11, 0x08, 0x00, 0x04, 0x00, 0x04, 0x03,
+            0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11,
+            0x01, 0xff, 0xc4, 0x00, 0x1f, 0x00, 0x00, 0x01,
+            0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+            0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+            0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00,
+            0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05,
+            0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d, 0x01,
+            0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21,
+            0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22,
+            0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23,
+            0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24,
+            0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17,
+            0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29,
+            0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a,
+            0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a,
+            0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+            0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+            0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+            0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+            0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+            0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,
+            0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+            0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6,
+            0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5,
+            0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3,
+            0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
+            0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+            0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01, 0x00, 0x03,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+            0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+            0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00,
+            0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07,
+            0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00,
+            0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+            0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13,
+            0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1,
+            0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15,
+            0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1,
+            0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27,
+            0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39,
+            0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+            0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+            0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+            0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+            0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
+            0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+            0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
+            0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5,
+            0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4,
+            0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
+            0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2,
+            0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+            0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+            0xfa, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00,
+            0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf9,
+            0xf7, 0xfb, 0x67, 0x56, 0xff, 0x00, 0x9f, 0xf8,
+            0x3f, 0xf0, 0x51, 0xa7, 0xff, 0x00, 0xf2, 0x3d,
+            0x7e, 0x6f, 0xfd, 0xab, 0x94, 0x7f, 0xd0, 0x9a,
+            0x8f, 0xfe, 0x0d, 0xc7, 0x7f, 0xf3, 0x61, 0xfd,
+            0xa7, 0xff, 0x00, 0x10, 0x77, 0x0d, 0xff, 0x00,
+            0x43, 0xec, 0xcf, 0xff, 0x00, 0x0b, 0xab, 0x1f,
+            0xff, 0xd9,
+        ];
+
+        let decodeDone;
+
+        decodeDone = testDecodeRect(decoder, 0, 0, 4, 4, data1, display, 24);
+        expect(decodeDone).to.be.true;
+
+        display.fillRect(0, 0, 4, 4, [128, 128, 128, 255]);
+
+        let data2 = [
+            // JPEG data
+            0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46,
+            0x49, 0x46, 0x00, 0x01, 0x01, 0x01, 0x01, 0x2c,
+            0x01, 0x2c, 0x00, 0x73, 0xff, 0xc0, 0x00, 0x11,
+            0x08, 0x00, 0x04, 0x00, 0x04, 0x03, 0x01, 0x11,
+            0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff,
+            0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11,
+            0x03, 0x11, 0x00, 0x3f, 0x00, 0xf9, 0xf7, 0xfb,
+            0x67, 0x56, 0xff, 0x00, 0x9f, 0xf8, 0x3f, 0xf0,
+            0x51, 0xa7, 0xff, 0x00, 0xf2, 0x3d, 0x7e, 0x6f,
+            0xfd, 0xab, 0x94, 0x7f, 0xd0, 0x9a, 0x8f, 0xfe,
+            0x0d, 0xc7, 0x7f, 0xf3, 0x61, 0xfd, 0xa7, 0xff,
+            0x00, 0x10, 0x77, 0x0d, 0xff, 0x00, 0x43, 0xec,
+            0xcf, 0xff, 0x00, 0x0b, 0xab, 0x1f, 0xff, 0xd9,
+        ];
+
+        decodeDone = testDecodeRect(decoder, 0, 0, 4, 4, data2, display, 24);
+        expect(decodeDone).to.be.true;
+
+        let targetData = new Uint8Array([
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255
+        ]);
+
+        // Browsers have rounding errors, so we need an approximate
+        // comparing function
+        function almost(a, b) {
+            let diff = Math.abs(a - b);
+            return diff < 5;
+        }
+
+        await display.flush();
+        expect(display).to.have.displayed(targetData, almost);
+    });
+});

VM/novnc/tests/test.keyboard.js

@@ -0,0 +1,591 @@
+const expect = chai.expect;
+
+import Keyboard from '../core/input/keyboard.js';
+
+describe('Key Event Handling', function () {
+    "use strict";
+
+    // The real KeyboardEvent constructor might not work everywhere we
+    // want to run these tests
+    function keyevent(typeArg, KeyboardEventInit) {
+        const e = { type: typeArg };
+        for (let key in KeyboardEventInit) {
+            e[key] = KeyboardEventInit[key];
+        }
+        e.stopPropagation = sinon.spy();
+        e.preventDefault = sinon.spy();
+        e.getModifierState = function (key) {
+            return e[key];
+        };
+
+        return e;
+    }
+
+    describe('Decode Keyboard Events', function () {
+        it('should decode keydown events', function (done) {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                expect(keysym).to.be.equal(0x61);
+                expect(code).to.be.equal('KeyA');
+                expect(down).to.be.equal(true);
+                done();
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
+        });
+        it('should decode keyup events', function (done) {
+            let calls = 0;
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                expect(keysym).to.be.equal(0x61);
+                expect(code).to.be.equal('KeyA');
+                if (calls++ === 1) {
+                    expect(down).to.be.equal(false);
+                    done();
+                }
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
+            kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
+        });
+    });
+
+    describe('Fake keyup', function () {
+        it('should fake keyup events for virtual keyboards', function (done) {
+            let count = 0;
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                switch (count++) {
+                    case 0:
+                        expect(keysym).to.be.equal(0x61);
+                        expect(code).to.be.equal('Unidentified');
+                        expect(down).to.be.equal(true);
+                        break;
+                    case 1:
+                        expect(keysym).to.be.equal(0x61);
+                        expect(code).to.be.equal('Unidentified');
+                        expect(down).to.be.equal(false);
+                        done();
+                }
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'Unidentified', key: 'a'}));
+        });
+    });
+
+    describe('Track Key State', function () {
+        it('should send release using the same keysym as the press', function (done) {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                expect(keysym).to.be.equal(0x61);
+                expect(code).to.be.equal('KeyA');
+                if (!down) {
+                    done();
+                }
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
+            kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'b'}));
+        });
+        it('should send the same keysym for multiple presses', function () {
+            let count = 0;
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                expect(keysym).to.be.equal(0x61);
+                expect(code).to.be.equal('KeyA');
+                expect(down).to.be.equal(true);
+                count++;
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'b'}));
+            expect(count).to.be.equal(2);
+        });
+        it('should do nothing on keyup events if no keys are down', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
+            expect(kbd.onkeyevent).to.not.have.been.called;
+        });
+
+        describe('Legacy Events', function () {
+            it('should track keys using keyCode if no code', function (done) {
+                const kbd = new Keyboard(document);
+                kbd.onkeyevent = (keysym, code, down) => {
+                    expect(keysym).to.be.equal(0x61);
+                    expect(code).to.be.equal('Platform65');
+                    if (!down) {
+                        done();
+                    }
+                };
+                kbd._handleKeyDown(keyevent('keydown', {keyCode: 65, key: 'a'}));
+                kbd._handleKeyUp(keyevent('keyup', {keyCode: 65, key: 'b'}));
+            });
+            it('should ignore compositing code', function () {
+                const kbd = new Keyboard(document);
+                kbd.onkeyevent = (keysym, code, down) => {
+                    expect(keysym).to.be.equal(0x61);
+                    expect(code).to.be.equal('Unidentified');
+                };
+                kbd._handleKeyDown(keyevent('keydown', {keyCode: 229, key: 'a'}));
+            });
+            it('should track keys using keyIdentifier if no code', function (done) {
+                const kbd = new Keyboard(document);
+                kbd.onkeyevent = (keysym, code, down) => {
+                    expect(keysym).to.be.equal(0x61);
+                    expect(code).to.be.equal('Platform65');
+                    if (!down) {
+                        done();
+                    }
+                };
+                kbd._handleKeyDown(keyevent('keydown', {keyIdentifier: 'U+0041', key: 'a'}));
+                kbd._handleKeyUp(keyevent('keyup', {keyIdentifier: 'U+0041', key: 'b'}));
+            });
+        });
+    });
+
+    describe('Shuffle modifiers on macOS', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+            window.navigator.platform = "Mac x86_64";
+        });
+        afterEach(function () {
+            Object.defineProperty(window, "navigator", origNavigator);
+        });
+
+        it('should change Alt to AltGraph', function () {
+            let count = 0;
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                switch (count++) {
+                    case 0:
+                        expect(keysym).to.be.equal(0xFF7E);
+                        expect(code).to.be.equal('AltLeft');
+                        break;
+                    case 1:
+                        expect(keysym).to.be.equal(0xFE03);
+                        expect(code).to.be.equal('AltRight');
+                        break;
+                }
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'AltLeft', key: 'Alt', location: 1}));
+            kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2}));
+            expect(count).to.be.equal(2);
+        });
+        it('should change left Super to Alt', function (done) {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                expect(keysym).to.be.equal(0xFFE9);
+                expect(code).to.be.equal('MetaLeft');
+                done();
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'MetaLeft', key: 'Meta', location: 1}));
+        });
+        it('should change right Super to left Super', function (done) {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = (keysym, code, down) => {
+                expect(keysym).to.be.equal(0xFFEB);
+                expect(code).to.be.equal('MetaRight');
+                done();
+            };
+            kbd._handleKeyDown(keyevent('keydown', {code: 'MetaRight', key: 'Meta', location: 2}));
+        });
+    });
+
+    describe('Meta key combination on iOS and macOS', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+            if (window.navigator.platform !== undefined) {
+                // Object.defineProperty() doesn't work properly in old
+                // versions of Chrome
+                this.skip();
+            }
+        });
+
+        afterEach(function () {
+            if (origNavigator !== undefined) {
+                Object.defineProperty(window, "navigator", origNavigator);
+            }
+        });
+
+        it('should send keyup when meta key is pressed on iOS', function () {
+            window.navigator.platform = "iPad";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'MetaRight', key: 'Meta', location: 2, metaKey: true}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a', metaKey: true}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0x61, "KeyA", true);
+            expect(kbd.onkeyevent).to.have.been.calledWith(0x61, "KeyA", false);
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyUp(keyevent('keyup', {code: 'MetaRight', key: 'Meta', location: 2, metaKey: true}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+        });
+
+        it('should send keyup when meta key is pressed on macOS', function () {
+            window.navigator.platform = "Mac";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'MetaRight', key: 'Meta', location: 2, metaKey: true}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a', metaKey: true}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0x61, "KeyA", true);
+            expect(kbd.onkeyevent).to.have.been.calledWith(0x61, "KeyA", false);
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyUp(keyevent('keyup', {code: 'MetaRight', key: 'Meta', location: 2, metaKey: true}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+        });
+    });
+
+    describe('Caps Lock on iOS and macOS', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+        });
+
+        afterEach(function () {
+            Object.defineProperty(window, "navigator", origNavigator);
+        });
+
+        it('should toggle caps lock on key press on iOS', function () {
+            window.navigator.platform = "iPad";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'CapsLock', key: 'CapsLock'}));
+
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xFFE5, "CapsLock", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xFFE5, "CapsLock", false);
+        });
+
+        it('should toggle caps lock on key press on mac', function () {
+            window.navigator.platform = "Mac";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'CapsLock', key: 'CapsLock'}));
+
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xFFE5, "CapsLock", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xFFE5, "CapsLock", false);
+        });
+
+        it('should toggle caps lock on key release on iOS', function () {
+            window.navigator.platform = "iPad";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyUp(keyevent('keyup', {code: 'CapsLock', key: 'CapsLock'}));
+
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xFFE5, "CapsLock", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xFFE5, "CapsLock", false);
+        });
+
+        it('should toggle caps lock on key release on mac', function () {
+            window.navigator.platform = "Mac";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyUp(keyevent('keyup', {code: 'CapsLock', key: 'CapsLock'}));
+
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xFFE5, "CapsLock", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xFFE5, "CapsLock", false);
+        });
+    });
+
+    describe('Modifier status info', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+        });
+
+        afterEach(function () {
+            Object.defineProperty(window, "navigator", origNavigator);
+        });
+
+        it('should provide caps lock state', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'A', NumLock: false, CapsLock: true}));
+
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0x41, "KeyA", true, false, true);
+        });
+
+        it('should provide num lock state', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'A', NumLock: true, CapsLock: false}));
+
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0x41, "KeyA", true, true, false);
+        });
+
+        it('should have no num lock state on mac', function () {
+            window.navigator.platform = "Mac";
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'A', NumLock: false, CapsLock: true}));
+
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0x41, "KeyA", true, null, true);
+        });
+    });
+
+    describe('Japanese IM keys on Windows', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+            window.navigator.platform = "Windows";
+        });
+
+        afterEach(function () {
+            Object.defineProperty(window, "navigator", origNavigator);
+        });
+
+        const keys = { 'Zenkaku': 0xff2a, 'Hankaku': 0xff2a,
+                       'Alphanumeric': 0xff30, 'Katakana': 0xff26,
+                       'Hiragana': 0xff25, 'Romaji': 0xff24,
+                       'KanaMode': 0xff24 };
+        for (let [key, keysym] of Object.entries(keys)) {
+            it(`should fake key release for ${key} on Windows`, function () {
+                let kbd = new Keyboard(document);
+                kbd.onkeyevent = sinon.spy();
+                kbd._handleKeyDown(keyevent('keydown', {code: 'FakeIM', key: key}));
+
+                expect(kbd.onkeyevent).to.have.been.calledTwice;
+                expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(keysym, "FakeIM", true);
+                expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(keysym, "FakeIM", false);
+            });
+        }
+    });
+
+    describe('Escape AltGraph on Windows', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+            window.navigator.platform = "Windows x86_64";
+
+            this.clock = sinon.useFakeTimers();
+        });
+        afterEach(function () {
+            Object.defineProperty(window, "navigator", origNavigator);
+            if (this.clock !== undefined) {
+                this.clock.restore();
+            }
+        });
+
+        it('should supress ControlLeft until it knows if it is AltGr', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
+            expect(kbd.onkeyevent).to.not.have.been.called;
+        });
+
+        it('should not trigger on repeating ControlLeft', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xffe3, "ControlLeft", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xffe3, "ControlLeft", true);
+        });
+
+        it('should not supress ControlRight', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlRight', key: 'Control', location: 2}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe4, "ControlRight", true);
+        });
+
+        it('should release ControlLeft after 100 ms', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
+            expect(kbd.onkeyevent).to.not.have.been.called;
+            this.clock.tick(100);
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe3, "ControlLeft", true);
+        });
+
+        it('should release ControlLeft on other key press', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
+            expect(kbd.onkeyevent).to.not.have.been.called;
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xffe3, "ControlLeft", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0x61, "KeyA", true);
+
+            // Check that the timer is properly dead
+            kbd.onkeyevent.resetHistory();
+            this.clock.tick(100);
+            expect(kbd.onkeyevent).to.not.have.been.called;
+        });
+
+        it('should release ControlLeft on other key release', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'KeyA', key: 'a'}));
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0x61, "KeyA", true);
+            kbd._handleKeyUp(keyevent('keyup', {code: 'KeyA', key: 'a'}));
+            expect(kbd.onkeyevent).to.have.been.calledThrice;
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xffe3, "ControlLeft", true);
+            expect(kbd.onkeyevent.thirdCall).to.have.been.calledWith(0x61, "KeyA", false);
+
+            // Check that the timer is properly dead
+            kbd.onkeyevent.resetHistory();
+            this.clock.tick(100);
+            expect(kbd.onkeyevent).to.not.have.been.called;
+        });
+
+        it('should generate AltGraph for quick Ctrl+Alt sequence', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1, timeStamp: Date.now()}));
+            this.clock.tick(20);
+            kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2, timeStamp: Date.now()}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xfe03, 'AltRight', true);
+
+            // Check that the timer is properly dead
+            kbd.onkeyevent.resetHistory();
+            this.clock.tick(100);
+            expect(kbd.onkeyevent).to.not.have.been.called;
+        });
+
+        it('should generate Ctrl, Alt for slow Ctrl+Alt sequence', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ControlLeft', key: 'Control', location: 1, timeStamp: Date.now()}));
+            this.clock.tick(60);
+            kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2, timeStamp: Date.now()}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent.firstCall).to.have.been.calledWith(0xffe3, "ControlLeft", true);
+            expect(kbd.onkeyevent.secondCall).to.have.been.calledWith(0xffea, "AltRight", true);
+
+            // Check that the timer is properly dead
+            kbd.onkeyevent.resetHistory();
+            this.clock.tick(100);
+            expect(kbd.onkeyevent).to.not.have.been.called;
+        });
+
+        it('should pass through single Alt', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'Alt', location: 2}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffea, 'AltRight', true);
+        });
+
+        it('should pass through single AltGr', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+            kbd._handleKeyDown(keyevent('keydown', {code: 'AltRight', key: 'AltGraph', location: 2}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xfe03, 'AltRight', true);
+        });
+    });
+
+    describe('Missing Shift keyup on Windows', function () {
+        let origNavigator;
+        beforeEach(function () {
+            // window.navigator is a protected read-only property in many
+            // environments, so we need to redefine it whilst running these
+            // tests.
+            origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+            Object.defineProperty(window, "navigator", {value: {}});
+            window.navigator.platform = "Windows x86_64";
+
+            this.clock = sinon.useFakeTimers();
+        });
+        afterEach(function () {
+            Object.defineProperty(window, "navigator", origNavigator);
+            if (this.clock !== undefined) {
+                this.clock.restore();
+            }
+        });
+
+        it('should fake a left Shift keyup', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ShiftLeft', key: 'Shift', location: 1}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe1, 'ShiftLeft', true);
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ShiftRight', key: 'Shift', location: 2}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe2, 'ShiftRight', true);
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyUp(keyevent('keyup', {code: 'ShiftLeft', key: 'Shift', location: 1}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe2, 'ShiftRight', false);
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe1, 'ShiftLeft', false);
+        });
+
+        it('should fake a right Shift keyup', function () {
+            const kbd = new Keyboard(document);
+            kbd.onkeyevent = sinon.spy();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ShiftLeft', key: 'Shift', location: 1}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe1, 'ShiftLeft', true);
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyDown(keyevent('keydown', {code: 'ShiftRight', key: 'Shift', location: 2}));
+            expect(kbd.onkeyevent).to.have.been.calledOnce;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe2, 'ShiftRight', true);
+            kbd.onkeyevent.resetHistory();
+
+            kbd._handleKeyUp(keyevent('keyup', {code: 'ShiftRight', key: 'Shift', location: 2}));
+            expect(kbd.onkeyevent).to.have.been.calledTwice;
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe2, 'ShiftRight', false);
+            expect(kbd.onkeyevent).to.have.been.calledWith(0xffe1, 'ShiftLeft', false);
+        });
+    });
+});

VM/novnc/tests/test.localization.js

@@ -0,0 +1,146 @@
+const expect = chai.expect;
+import _, { Localizer, l10n } from '../app/localization.js';
+
+describe('Localization', function () {
+    "use strict";
+
+    let origNavigator;
+    let fetch;
+
+    beforeEach(function () {
+        // window.navigator is a protected read-only property in many
+        // environments, so we need to redefine it whilst running these
+        // tests.
+        origNavigator = Object.getOwnPropertyDescriptor(window, "navigator");
+
+        Object.defineProperty(window, "navigator", {value: {}});
+        window.navigator.languages = [];
+
+        fetch = sinon.stub(window, "fetch");
+        fetch.resolves(new Response("{}"));
+    });
+    afterEach(function () {
+        fetch.restore();
+
+        Object.defineProperty(window, "navigator", origNavigator);
+    });
+
+    describe('Singleton', function () {
+        it('should export a singleton object', function () {
+            expect(l10n).to.be.instanceOf(Localizer);
+        });
+        it('should export a singleton translation function', async function () {
+            // FIXME: Can we use some spy instead?
+            window.navigator.languages = ["de"];
+            fetch.resolves(new Response(JSON.stringify({ "Foobar": "gazonk" })));
+            await l10n.setup(["de"]);
+            expect(_("Foobar")).to.equal("gazonk");
+        });
+    });
+
+    describe('language selection', function () {
+        it('should use English by default', function () {
+            let lclz = new Localizer();
+            expect(lclz.language).to.equal('en');
+        });
+        it('should use English if no user language matches', async function () {
+            window.navigator.languages = ["nl", "de"];
+            let lclz = new Localizer();
+            await lclz.setup(["es", "fr"]);
+            expect(lclz.language).to.equal('en');
+        });
+        it('should fall back to generic English for other English', async function () {
+            window.navigator.languages = ["en-AU", "de"];
+            let lclz = new Localizer();
+            await lclz.setup(["de", "fr", "en-GB"]);
+            expect(lclz.language).to.equal('en');
+        });
+        it('should prefer specific English over generic', async function () {
+            window.navigator.languages = ["en-GB", "de"];
+            let lclz = new Localizer();
+            await lclz.setup(["de", "en-AU", "en-GB"]);
+            expect(lclz.language).to.equal('en-GB');
+        });
+        it('should use the most preferred user language', async function () {
+            window.navigator.languages = ["nl", "de", "fr"];
+            let lclz = new Localizer();
+            await lclz.setup(["es", "fr", "de"]);
+            expect(lclz.language).to.equal('de');
+        });
+        it('should prefer sub-languages languages', async function () {
+            window.navigator.languages = ["pt-BR"];
+            let lclz = new Localizer();
+            await lclz.setup(["pt", "pt-BR"]);
+            expect(lclz.language).to.equal('pt-BR');
+        });
+        it('should fall back to language "parents"', async function () {
+            window.navigator.languages = ["pt-BR"];
+            let lclz = new Localizer();
+            await lclz.setup(["fr", "pt", "de"]);
+            expect(lclz.language).to.equal('pt');
+        });
+        it('should not use specific language when user asks for a generic language', async function () {
+            window.navigator.languages = ["pt", "de"];
+            let lclz = new Localizer();
+            await lclz.setup(["fr", "pt-BR", "de"]);
+            expect(lclz.language).to.equal('de');
+        });
+        it('should handle underscore as a separator', async function () {
+            window.navigator.languages = ["pt-BR"];
+            let lclz = new Localizer();
+            await lclz.setup(["pt_BR"]);
+            expect(lclz.language).to.equal('pt_BR');
+        });
+        it('should handle difference in case', async function () {
+            window.navigator.languages = ["pt-br"];
+            let lclz = new Localizer();
+            await lclz.setup(["pt-BR"]);
+            expect(lclz.language).to.equal('pt-BR');
+        });
+    });
+
+    describe('Translation loading', function () {
+        it('should not fetch a translation for English', async function () {
+            window.navigator.languages = [];
+            let lclz = new Localizer();
+            await lclz.setup([]);
+            expect(fetch).to.not.have.been.called;
+        });
+        it('should fetch dictionary relative base URL', async function () {
+            window.navigator.languages = ["de", "fr"];
+            fetch.resolves(new Response('{ "Foobar": "gazonk" }'));
+            let lclz = new Localizer();
+            await lclz.setup(["ru", "fr"], "/some/path/");
+            expect(fetch).to.have.been.calledOnceWith("/some/path/fr.json");
+            expect(lclz.get("Foobar")).to.equal("gazonk");
+        });
+        it('should handle base URL without trailing slash', async function () {
+            window.navigator.languages = ["de", "fr"];
+            fetch.resolves(new Response('{ "Foobar": "gazonk" }'));
+            let lclz = new Localizer();
+            await lclz.setup(["ru", "fr"], "/some/path");
+            expect(fetch).to.have.been.calledOnceWith("/some/path/fr.json");
+            expect(lclz.get("Foobar")).to.equal("gazonk");
+        });
+        it('should handle current base URL', async function () {
+            window.navigator.languages = ["de", "fr"];
+            fetch.resolves(new Response('{ "Foobar": "gazonk" }'));
+            let lclz = new Localizer();
+            await lclz.setup(["ru", "fr"]);
+            expect(fetch).to.have.been.calledOnceWith("fr.json");
+            expect(lclz.get("Foobar")).to.equal("gazonk");
+        });
+        it('should fail if dictionary cannot be found', async function () {
+            window.navigator.languages = ["de", "fr"];
+            fetch.resolves(new Response('{}', { status: 404 }));
+            let lclz = new Localizer();
+            let ok = false;
+            try {
+                await lclz.setup(["ru", "fr"], "/some/path/");
+            } catch (e) {
+                ok = true;
+            }
+            expect(ok).to.be.true;
+        });
+    });
+});

VM/novnc/tests/test.raw.js

@@ -0,0 +1,154 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import RawDecoder from '../core/decoders/raw.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+describe('Raw Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new RawDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle the Raw encoding', function () {
+        let done;
+
+        done = testDecodeRect(decoder, 0, 0, 2, 2,
+                              [0xff, 0x00, 0x00, 0,
+                               0x00, 0xff, 0x00, 0,
+                               0x00, 0xff, 0x00, 0,
+                               0xff, 0x00, 0x00, 0],
+                              display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 0, 2, 2,
+                              [0x00, 0x00, 0xff, 0,
+                               0x00, 0x00, 0xff, 0,
+                               0x00, 0x00, 0xff, 0,
+                               0x00, 0x00, 0xff, 0],
+                              display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 2, 4, 1,
+                              [0xee, 0x00, 0xff, 0,
+                               0x00, 0xee, 0xff, 0,
+                               0xaa, 0xee, 0xff, 0,
+                               0xab, 0xee, 0xff, 0],
+                              display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 3, 4, 1,
+                              [0xee, 0x00, 0xff, 0,
+                               0x00, 0xee, 0xff, 0,
+                               0xaa, 0xee, 0xff, 0,
+                               0xab, 0xee, 0xff, 0],
+                              display, 24);
+        expect(done).to.be.true;
+
+        let targetData = new Uint8Array([
+            0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0xff, 0x00, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0xee, 0x00, 0xff, 255, 0x00, 0xee, 0xff, 255, 0xaa, 0xee, 0xff, 255, 0xab, 0xee, 0xff, 255,
+            0xee, 0x00, 0xff, 255, 0x00, 0xee, 0xff, 255, 0xaa, 0xee, 0xff, 255, 0xab, 0xee, 0xff, 255
+        ]);
+
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle the Raw encoding in low colour mode', function () {
+        let done;
+
+        done = testDecodeRect(decoder, 0, 0, 2, 2,
+                              [0x30, 0x30, 0x30, 0x30],
+                              display, 8);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 0, 2, 2,
+                              [0x0c, 0x0c, 0x0c, 0x0c],
+                              display, 8);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 2, 4, 1,
+                              [0x0c, 0x0c, 0x30, 0x30],
+                              display, 8);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 3, 4, 1,
+                              [0x0c, 0x0c, 0x30, 0x30],
+                              display, 8);
+        expect(done).to.be.true;
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0, [], display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty rects in low colour mode', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0, [], display, 8);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+});

VM/novnc/tests/test.rre.js

@@ -0,0 +1,115 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import RREDecoder from '../core/decoders/rre.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+function push16(arr, num) {
+    arr.push((num >> 8) & 0xFF,
+             num & 0xFF);
+}
+
+function push32(arr, num) {
+    arr.push((num >> 24) & 0xFF,
+             (num >> 16) & 0xFF,
+             (num >>  8) & 0xFF,
+             num & 0xFF);
+}
+
+describe('RRE Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new RREDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    // TODO(directxman12): test rre_chunk_sz?
+
+    it('should handle the RRE encoding', function () {
+        let data = [];
+        push32(data, 2); // 2 subrects
+        push32(data, 0x00ff0000); // becomes 00ff0000 --> #00FF00 bg color
+        data.push(0x00); // becomes 0000ff00 --> #0000FF fg color
+        data.push(0x00);
+        data.push(0xff);
+        data.push(0x00);
+        push16(data, 0); // x: 0
+        push16(data, 0); // y: 0
+        push16(data, 2); // width: 2
+        push16(data, 2); // height: 2
+        data.push(0x00); // becomes 0000ff00 --> #0000FF fg color
+        data.push(0x00);
+        data.push(0xff);
+        data.push(0x00);
+        push16(data, 2); // x: 2
+        push16(data, 2); // y: 2
+        push16(data, 2); // width: 2
+        push16(data, 2); // height: 2
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0,
+                                  [ 0x00, 0x00, 0x00, 0x00,
+                                    0xff, 0xff, 0xff, 0xff ],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+});

VM/novnc/tests/test.tight.js

@@ -0,0 +1,482 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import TightDecoder from '../core/decoders/tight.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+describe('Tight Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new TightDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle fill rects', function () {
+        let done = testDecodeRect(decoder, 0, 0, 4, 4,
+                                  [0x80, 0xff, 0x88, 0x44],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255,
+            0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255,
+            0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255,
+            0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255, 0xff, 0x88, 0x44, 255,
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle uncompressed copy rects', function () {
+        let done;
+        let blueData = [ 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff ];
+        let greenData = [ 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00 ];
+
+        done = testDecodeRect(decoder, 0, 0, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 1, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 0, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 1, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 2, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 3, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 2, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 3, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle compressed copy rects', function () {
+        let data = [
+            // Control byte
+            0x00,
+            // Pixels (compressed)
+            0x15,
+            0x78, 0x9c, 0x63, 0x60, 0xf8, 0xcf, 0x00, 0x44,
+            0x60, 0x82, 0x01, 0x99, 0x8d, 0x29, 0x02, 0xa6,
+            0x00, 0x7e, 0xbf, 0x0f, 0xf1 ];
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle uncompressed mono rects', function () {
+        let data = [
+            // Control bytes
+            0x40, 0x01,
+            // Palette
+            0x01, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00,
+            // Pixels
+            0x30, 0x30, 0xc0, 0xc0 ];
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle compressed mono rects', function () {
+        display.resize(4, 12);
+
+        let data = [
+            // Control bytes
+            0x40, 0x01,
+            // Palette
+            0x01, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00,
+            // Pixels (compressed)
+            0x0e,
+            0x78, 0x9c, 0x33, 0x30, 0x38, 0x70, 0xc0, 0x00,
+            0x8a, 0x01, 0x21, 0x3c, 0x05, 0xa1 ];
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 12, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle uncompressed palette rects', function () {
+        let done;
+        let data1 = [
+            // Control bytes
+            0x40, 0x01,
+            // Palette
+            0x02, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
+            // Pixels
+            0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01 ];
+        let data2 = [
+            // Control bytes
+            0x40, 0x01,
+            // Palette
+            0x02, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
+            // Pixels
+            0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00 ];
+
+        done = testDecodeRect(decoder, 0, 0, 4, 2, data1, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 2, 4, 2, data2, display, 24);
+        expect(done).to.be.true;
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle compressed palette rects', function () {
+        let data = [
+            // Control bytes
+            0x40, 0x01,
+            // Palette
+            0x02, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
+            // Pixels (compressed)
+            0x12,
+            0x78, 0x9c, 0x63, 0x60, 0x60, 0x64, 0x64, 0x00,
+            0x62, 0x08, 0xc9, 0xc0, 0x00, 0x00, 0x00, 0x54,
+            0x00, 0x09 ];
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle uncompressed gradient rects', function () {
+        let done;
+        let blueData = [ 0x40, 0x02, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00 ];
+        let greenData = [ 0x40, 0x02, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 ];
+
+        done = testDecodeRect(decoder, 0, 0, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 1, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 0, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 1, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 2, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 0, 3, 2, 1, greenData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 2, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+        done = testDecodeRect(decoder, 2, 3, 2, 1, blueData, display, 24);
+        expect(done).to.be.true;
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle compressed gradient rects', function () {
+        let data = [
+            // Control byte
+            0x40, 0x02,
+            // Pixels (compressed)
+            0x18,
+            0x78, 0x9c, 0x62, 0x60, 0xf8, 0xcf, 0x00, 0x04,
+            0xff, 0x19, 0x19, 0xd0, 0x00, 0x44, 0x84, 0xf1,
+            0x3f, 0x9a, 0x30, 0x00, 0x00, 0x00, 0xff, 0xff ];
+
+        let done = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty copy rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0, [ 0x00 ], display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty palette rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0,
+                                  [ 0x40, 0x01, 0x01,
+                                    0xff, 0xff, 0xff,
+                                    0xff, 0xff, 0xff ], display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty gradient rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0,
+                                  [ 0x40, 0x02 ], display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle empty fill rects', function () {
+        display.fillRect(0, 0, 4, 4, [ 0x00, 0x00, 0xff ]);
+        display.fillRect(2, 0, 2, 2, [ 0x00, 0xff, 0x00 ]);
+        display.fillRect(0, 2, 2, 2, [ 0x00, 0xff, 0x00 ]);
+
+        let done = testDecodeRect(decoder, 1, 2, 0, 0,
+                                  [ 0x80, 0xff, 0xff, 0xff ],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0x00, 0xff, 255, 0x00, 0x00, 0xff, 255
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle JPEG rects', async function () {
+        let data = [
+            // Control bytes
+            0x90, 0xd6, 0x05,
+            // JPEG data
+            0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46,
+            0x49, 0x46, 0x00, 0x01, 0x01, 0x01, 0x00, 0x48,
+            0x00, 0x48, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x13,
+            0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20,
+            0x77, 0x69, 0x74, 0x68, 0x20, 0x47, 0x49, 0x4d,
+            0x50, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xff, 0xdb,
+            0x00, 0x43, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01, 0x01, 0xff, 0xc2, 0x00, 0x11, 0x08,
+            0x00, 0x04, 0x00, 0x04, 0x03, 0x01, 0x11, 0x00,
+            0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4,
+            0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x07, 0xff, 0xc4, 0x00, 0x14,
+            0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x08, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01,
+            0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00, 0x01,
+            0x1e, 0x0a, 0xa7, 0x7f, 0xff, 0xc4, 0x00, 0x14,
+            0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
+            0x00, 0x01, 0x05, 0x02, 0x5d, 0x74, 0x41, 0x47,
+            0xff, 0xc4, 0x00, 0x1f, 0x11, 0x00, 0x01, 0x04,
+            0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x05,
+            0x07, 0x08, 0x14, 0x16, 0x03, 0x15, 0x17, 0x25,
+            0x26, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03, 0x01,
+            0x01, 0x3f, 0x01, 0xad, 0x35, 0xa6, 0x13, 0xb8,
+            0x10, 0x98, 0x5d, 0x8a, 0xb1, 0x41, 0x7e, 0x43,
+            0x99, 0x24, 0x3d, 0x8f, 0x70, 0x30, 0xd8, 0xcb,
+            0x44, 0xbb, 0x7d, 0x48, 0xb5, 0xf8, 0x18, 0x7f,
+            0xe7, 0xc1, 0x9f, 0x86, 0x45, 0x9b, 0xfa, 0xf1,
+            0x61, 0x96, 0x46, 0xbf, 0x56, 0xc8, 0x8b, 0x2b,
+            0x0b, 0x35, 0x6e, 0x4b, 0x8a, 0x95, 0x6a, 0xf9,
+            0xff, 0x00, 0xff, 0xc4, 0x00, 0x1f, 0x11, 0x00,
+            0x01, 0x04, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+            0x02, 0x04, 0x05, 0x12, 0x13, 0x14, 0x01, 0x06,
+            0x11, 0x22, 0x23, 0xff, 0xda, 0x00, 0x08, 0x01,
+            0x02, 0x01, 0x01, 0x3f, 0x01, 0x85, 0x85, 0x8c,
+            0xec, 0x31, 0x8d, 0xa6, 0x26, 0x1b, 0x6e, 0x48,
+            0xbc, 0xcd, 0xb0, 0xe3, 0x33, 0x86, 0xf9, 0x35,
+            0xdc, 0x15, 0xa8, 0xbe, 0x4d, 0x4a, 0x10, 0x22,
+            0x80, 0x00, 0x91, 0xe8, 0x24, 0xda, 0xb6, 0x57,
+            0x95, 0xf2, 0xa5, 0x73, 0xff, 0xc4, 0x00, 0x1e,
+            0x10, 0x00, 0x01, 0x04, 0x03, 0x00, 0x03, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x03, 0x01, 0x02, 0x04, 0x12, 0x05, 0x11,
+            0x13, 0x14, 0x22, 0x23, 0xff, 0xda, 0x00, 0x08,
+            0x01, 0x01, 0x00, 0x06, 0x3f, 0x02, 0x91, 0x89,
+            0xc4, 0xc8, 0xf1, 0x60, 0x45, 0xe5, 0xc0, 0x1c,
+            0x80, 0x7a, 0x77, 0x00, 0xe4, 0x97, 0xeb, 0x24,
+            0x66, 0x33, 0xac, 0x63, 0x11, 0xfe, 0xe4, 0x76,
+            0xad, 0x56, 0xe9, 0xa8, 0x88, 0x9f, 0xff, 0xc4,
+            0x00, 0x14, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xda, 0x00, 0x08,
+            0x01, 0x01, 0x00, 0x01, 0x3f, 0x21, 0x68, 0x3f,
+            0x92, 0x17, 0x81, 0x1f, 0x7f, 0xff, 0xda, 0x00,
+            0x0c, 0x03, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00,
+            0x00, 0x00, 0x10, 0x5f, 0xff, 0xc4, 0x00, 0x14,
+            0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xda, 0x00, 0x08, 0x01, 0x03,
+            0x01, 0x01, 0x3f, 0x10, 0x03, 0xeb, 0x11, 0xe4,
+            0xa7, 0xe3, 0xff, 0x00, 0xff, 0xc4, 0x00, 0x14,
+            0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xda, 0x00, 0x08, 0x01, 0x02,
+            0x01, 0x01, 0x3f, 0x10, 0x6b, 0xd3, 0x02, 0xdc,
+            0x9a, 0xf4, 0xff, 0x00, 0xff, 0xc4, 0x00, 0x14,
+            0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
+            0x00, 0x01, 0x3f, 0x10, 0x62, 0x7b, 0x3a, 0xd0,
+            0x3f, 0xeb, 0xff, 0x00, 0xff, 0xd9,
+        ];
+
+        let decodeDone = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+        expect(decodeDone).to.be.true;
+
+        let targetData = new Uint8Array([
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255
+        ]);
+
+        // Browsers have rounding errors, so we need an approximate
+        // comparing function
+        function almost(a, b) {
+            let diff = Math.abs(a - b);
+            return diff < 5;
+        }
+
+        await display.flush();
+        expect(display).to.have.displayed(targetData, almost);
+    });
+});

VM/novnc/tests/test.tightpng.js

@@ -0,0 +1,145 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import TightPngDecoder from '../core/decoders/tightpng.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+describe('TightPng Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new TightPngDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle the TightPng encoding', async function () {
+        let data = [
+            // Control bytes
+            0xa0, 0xb4, 0x04,
+            // PNG data
+            0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+            0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+            0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+            0x08, 0x02, 0x00, 0x00, 0x00, 0x26, 0x93, 0x09,
+            0x29, 0x00, 0x00, 0x01, 0x84, 0x69, 0x43, 0x43,
+            0x50, 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6f,
+            0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x28, 0x91,
+            0x7d, 0x91, 0x3d, 0x48, 0xc3, 0x40, 0x18, 0x86,
+            0xdf, 0xa6, 0x6a, 0x45, 0x2a, 0x0e, 0x76, 0x10,
+            0x71, 0x08, 0x52, 0x9d, 0x2c, 0x88, 0x8a, 0x38,
+            0x6a, 0x15, 0x8a, 0x50, 0x21, 0xd4, 0x0a, 0xad,
+            0x3a, 0x98, 0x5c, 0xfa, 0x07, 0x4d, 0x1a, 0x92,
+            0x14, 0x17, 0x47, 0xc1, 0xb5, 0xe0, 0xe0, 0xcf,
+            0x62, 0xd5, 0xc1, 0xc5, 0x59, 0x57, 0x07, 0x57,
+            0x41, 0x10, 0xfc, 0x01, 0x71, 0x72, 0x74, 0x52,
+            0x74, 0x91, 0x12, 0xbf, 0x4b, 0x0a, 0x2d, 0x62,
+            0xbc, 0xe3, 0xb8, 0x87, 0xf7, 0xbe, 0xf7, 0xe5,
+            0xee, 0x3b, 0x40, 0xa8, 0x97, 0x99, 0x66, 0x75,
+            0x8c, 0x03, 0x9a, 0x6e, 0x9b, 0xa9, 0x44, 0x5c,
+            0xcc, 0x64, 0x57, 0xc5, 0xd0, 0x2b, 0xba, 0x68,
+            0x86, 0x31, 0x8c, 0x2e, 0x99, 0x59, 0xc6, 0x9c,
+            0x24, 0x25, 0xe1, 0x3b, 0xbe, 0xee, 0x11, 0xe0,
+            0xfb, 0x5d, 0x8c, 0x67, 0xf9, 0xd7, 0xfd, 0x39,
+            0x7a, 0xd5, 0x9c, 0xc5, 0x80, 0x80, 0x48, 0x3c,
+            0xcb, 0x0c, 0xd3, 0x26, 0xde, 0x20, 0x9e, 0xde,
+            0xb4, 0x0d, 0xce, 0xfb, 0xc4, 0x11, 0x56, 0x94,
+            0x55, 0xe2, 0x73, 0xe2, 0x31, 0x93, 0x2e, 0x48,
+            0xfc, 0xc8, 0x75, 0xc5, 0xe3, 0x37, 0xce, 0x05,
+            0x97, 0x05, 0x9e, 0x19, 0x31, 0xd3, 0xa9, 0x79,
+            0xe2, 0x08, 0xb1, 0x58, 0x68, 0x63, 0xa5, 0x8d,
+            0x59, 0xd1, 0xd4, 0x88, 0xa7, 0x88, 0xa3, 0xaa,
+            0xa6, 0x53, 0xbe, 0x90, 0xf1, 0x58, 0xe5, 0xbc,
+            0xc5, 0x59, 0x2b, 0x57, 0x59, 0xf3, 0x9e, 0xfc,
+            0x85, 0xe1, 0x9c, 0xbe, 0xb2, 0xcc, 0x75, 0x5a,
+            0x43, 0x48, 0x60, 0x11, 0x4b, 0x90, 0x20, 0x42,
+            0x41, 0x15, 0x25, 0x94, 0x61, 0x23, 0x46, 0xbb,
+            0x4e, 0x8a, 0x85, 0x14, 0x9d, 0xc7, 0x7d, 0xfc,
+            0x83, 0xae, 0x5f, 0x22, 0x97, 0x42, 0xae, 0x12,
+            0x18, 0x39, 0x16, 0x50, 0x81, 0x06, 0xd9, 0xf5,
+            0x83, 0xff, 0xc1, 0xef, 0xde, 0x5a, 0xf9, 0xc9,
+            0x09, 0x2f, 0x29, 0x1c, 0x07, 0x3a, 0x5f, 0x1c,
+            0xe7, 0x63, 0x04, 0x08, 0xed, 0x02, 0x8d, 0x9a,
+            0xe3, 0x7c, 0x1f, 0x3b, 0x4e, 0xe3, 0x04, 0x08,
+            0x3e, 0x03, 0x57, 0x7a, 0xcb, 0x5f, 0xa9, 0x03,
+            0x33, 0x9f, 0xa4, 0xd7, 0x5a, 0x5a, 0xf4, 0x08,
+            0xe8, 0xdb, 0x06, 0x2e, 0xae, 0x5b, 0x9a, 0xb2,
+            0x07, 0x5c, 0xee, 0x00, 0x03, 0x4f, 0x86, 0x6c,
+            0xca, 0xae, 0x14, 0xa4, 0x25, 0xe4, 0xf3, 0xc0,
+            0xfb, 0x19, 0x7d, 0x53, 0x16, 0xe8, 0xbf, 0x05,
+            0x7a, 0xd6, 0xbc, 0xbe, 0x35, 0xcf, 0x71, 0xfa,
+            0x00, 0xa4, 0xa9, 0x57, 0xc9, 0x1b, 0xe0, 0xe0,
+            0x10, 0x18, 0x2d, 0x50, 0xf6, 0xba, 0xcf, 0xbb,
+            0xbb, 0xdb, 0xfb, 0xf6, 0x6f, 0x4d, 0xb3, 0x7f,
+            0x3f, 0x0a, 0x27, 0x72, 0x7d, 0x49, 0x29, 0x8b,
+            0xbb, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59,
+            0x73, 0x00, 0x00, 0x2e, 0x23, 0x00, 0x00, 0x2e,
+            0x23, 0x01, 0x78, 0xa5, 0x3f, 0x76, 0x00, 0x00,
+            0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xe4,
+            0x06, 0x06, 0x0c, 0x23, 0x1d, 0x3f, 0x9f, 0xbb,
+            0x94, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45, 0x58,
+            0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
+            0x00, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64,
+            0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x47, 0x49,
+            0x4d, 0x50, 0x57, 0x81, 0x0e, 0x17, 0x00, 0x00,
+            0x00, 0x1e, 0x49, 0x44, 0x41, 0x54, 0x08, 0xd7,
+            0x65, 0xc9, 0xb1, 0x0d, 0x00, 0x00, 0x08, 0x03,
+            0x20, 0xea, 0xff, 0x3f, 0xd7, 0xd5, 0x44, 0x56,
+            0x52, 0x90, 0xc2, 0x38, 0xa2, 0xd0, 0xbc, 0x59,
+            0x8a, 0x9f, 0x04, 0x05, 0x6b, 0x38, 0x7b, 0xb2,
+            0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44,
+            0xae, 0x42, 0x60, 0x82,
+        ];
+
+        let decodeDone = testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24);
+        expect(decodeDone).to.be.true;
+
+        let targetData = new Uint8Array([
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255, 0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255,
+            0x00, 0xff, 0x00, 255, 0x00, 0xff, 0x00, 255, 0xff, 0x00, 0x00, 255, 0xff, 0x00, 0x00, 255
+        ]);
+
+        // Firefox currently has some very odd rounding bug:
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1667747
+        function almost(a, b) {
+            let diff = Math.abs(a - b);
+            return diff < 30;
+        }
+
+        await display.flush();
+        expect(display).to.have.displayed(targetData, almost);
+    });
+});

VM/novnc/tests/test.util.js

@@ -0,0 +1,89 @@
+/* eslint-disable no-console */
+const expect = chai.expect;
+
+import * as Log from '../core/util/logging.js';
+import { encodeUTF8, decodeUTF8 } from '../core/util/strings.js';
+
+describe('Utils', function () {
+    "use strict";
+
+    describe('logging functions', function () {
+        beforeEach(function () {
+            sinon.spy(console, 'log');
+            sinon.spy(console, 'debug');
+            sinon.spy(console, 'warn');
+            sinon.spy(console, 'error');
+            sinon.spy(console, 'info');
+        });
+
+        afterEach(function () {
+            console.log.restore();
+            console.debug.restore();
+            console.warn.restore();
+            console.error.restore();
+            console.info.restore();
+            Log.initLogging();
+        });
+
+        it('should use noop for levels lower than the min level', function () {
+            Log.initLogging('warn');
+            Log.Debug('hi');
+            Log.Info('hello');
+            expect(console.log).to.not.have.been.called;
+        });
+
+        it('should use console.debug for Debug', function () {
+            Log.initLogging('debug');
+            Log.Debug('dbg');
+            expect(console.debug).to.have.been.calledWith('dbg');
+        });
+
+        it('should use console.info for Info', function () {
+            Log.initLogging('debug');
+            Log.Info('inf');
+            expect(console.info).to.have.been.calledWith('inf');
+        });
+
+        it('should use console.warn for Warn', function () {
+            Log.initLogging('warn');
+            Log.Warn('wrn');
+            expect(console.warn).to.have.been.called;
+            expect(console.warn).to.have.been.calledWith('wrn');
+        });
+
+        it('should use console.error for Error', function () {
+            Log.initLogging('error');
+            Log.Error('err');
+            expect(console.error).to.have.been.called;
+            expect(console.error).to.have.been.calledWith('err');
+        });
+    });
+
+    describe('string functions', function () {
+        it('should decode UTF-8 to DOMString correctly', function () {
+            const utf8string = '\xd0\x9f';
+            const domstring = decodeUTF8(utf8string);
+            expect(domstring).to.equal("П");
+        });
+
+        it('should encode DOMString to UTF-8 correctly', function () {
+            const domstring = "åäöa";
+            const utf8string = encodeUTF8(domstring);
+            expect(utf8string).to.equal('\xc3\xa5\xc3\xa4\xc3\xb6\x61');
+        });
+
+        it('should allow Latin-1 strings if allowLatin1 is set when decoding', function () {
+            const latin1string = '\xe5\xe4\xf6';
+            expect(() => decodeUTF8(latin1string)).to.throw(Error);
+            expect(decodeUTF8(latin1string, true)).to.equal('åäö');
+        });
+    });
+
+    // TODO(directxman12): test the conf_default and conf_defaults methods
+    // TODO(directxman12): test the event methods (addEvent, removeEvent, stopEvent)
+    // TODO(directxman12): figure out a good way to test getPosition and getEventPosition
+    // TODO(directxman12): figure out how to test the browser detection functions properly
+    //                     (we can't really test them against the browsers, except for Gecko
+    //                     via PhantomJS, the default test driver)
+});
+/* eslint-enable no-console */

VM/novnc/tests/test.websock.js

@@ -0,0 +1,628 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import FakeWebSocket from './fake.websocket.js';
+
+describe('Websock', function () {
+    "use strict";
+
+    describe('Receive queue methods', function () {
+        let sock, websock;
+
+        beforeEach(function () {
+            sock = new Websock();
+            websock = new FakeWebSocket();
+            websock._open();
+            sock.attach(websock);
+        });
+
+        describe('rQpeek8', function () {
+            it('should peek at the next byte without poping it off the queue', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd]));
+                expect(sock.rQpeek8()).to.equal(0xab);
+                expect(sock.rQpeek8()).to.equal(0xab);
+            });
+        });
+
+        describe('rQshift8()', function () {
+            it('should pop a single byte from the receive queue', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd]));
+                expect(sock.rQshift8()).to.equal(0xab);
+                expect(sock.rQshift8()).to.equal(0xcd);
+            });
+        });
+
+        describe('rQshift16()', function () {
+            it('should pop two bytes from the receive queue and return a single number', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34]));
+                expect(sock.rQshift16()).to.equal(0xabcd);
+                expect(sock.rQshift16()).to.equal(0x1234);
+            });
+        });
+
+        describe('rQshift32()', function () {
+            it('should pop four bytes from the receive queue and return a single number', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+                expect(sock.rQshift32()).to.equal(0xabcd1234);
+                expect(sock.rQshift32()).to.equal(0x88ee1133);
+            });
+        });
+
+        describe('rQshiftStr', function () {
+            it('should shift the given number of bytes off of the receive queue and return a string', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+                expect(sock.rQshiftStr(4)).to.equal('\xab\xcd\x12\x34');
+                expect(sock.rQshiftStr(4)).to.equal('\x88\xee\x11\x33');
+            });
+
+            it('should be able to handle very large strings', function () {
+                const BIG_LEN = 500000;
+                const incoming = new Uint8Array(BIG_LEN);
+                let expected = "";
+                let letterCode = 'a'.charCodeAt(0);
+                for (let i = 0; i < BIG_LEN; i++) {
+                    incoming[i] = letterCode;
+                    expected += String.fromCharCode(letterCode);
+
+                    if (letterCode < 'z'.charCodeAt(0)) {
+                        letterCode++;
+                    } else {
+                        letterCode = 'a'.charCodeAt(0);
+                    }
+                }
+                websock._receiveData(incoming);
+
+                const shifted = sock.rQshiftStr(BIG_LEN);
+
+                expect(shifted).to.be.equal(expected);
+            });
+        });
+
+        describe('rQshiftBytes', function () {
+            it('should shift the given number of bytes of the receive queue and return an array', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+                expect(sock.rQshiftBytes(4)).to.array.equal(new Uint8Array([0xab, 0xcd, 0x12, 0x34]));
+                expect(sock.rQshiftBytes(4)).to.array.equal(new Uint8Array([0x88, 0xee, 0x11, 0x33]));
+            });
+
+            it('should return a shared array if requested', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+                const bytes = sock.rQshiftBytes(4, false);
+                expect(bytes).to.array.equal(new Uint8Array([0xab, 0xcd, 0x12, 0x34]));
+                expect(bytes.buffer.byteLength).to.not.equal(bytes.length);
+            });
+        });
+
+        describe('rQpeekBytes', function () {
+            it('should not modify the receive queue', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+                expect(sock.rQpeekBytes(4)).to.array.equal(new Uint8Array([0xab, 0xcd, 0x12, 0x34]));
+                expect(sock.rQpeekBytes(4)).to.array.equal(new Uint8Array([0xab, 0xcd, 0x12, 0x34]));
+            });
+
+            it('should return a shared array if requested', function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+                const bytes = sock.rQpeekBytes(4, false);
+                expect(bytes).to.array.equal(new Uint8Array([0xab, 0xcd, 0x12, 0x34]));
+                expect(bytes.buffer.byteLength).to.not.equal(bytes.length);
+            });
+        });
+
+        describe('rQwait', function () {
+            beforeEach(function () {
+                websock._receiveData(new Uint8Array([0xab, 0xcd, 0x12, 0x34,
+                                                     0x88, 0xee, 0x11, 0x33]));
+            });
+
+            it('should return true if there are not enough bytes in the receive queue', function () {
+                expect(sock.rQwait('hi', 9)).to.be.true;
+            });
+
+            it('should return false if there are enough bytes in the receive queue', function () {
+                expect(sock.rQwait('hi', 8)).to.be.false;
+            });
+
+            it('should return true and reduce rQi by "goback" if there are not enough bytes', function () {
+                expect(sock.rQshift32()).to.equal(0xabcd1234);
+                expect(sock.rQwait('hi', 8, 2)).to.be.true;
+                expect(sock.rQshift32()).to.equal(0x123488ee);
+            });
+
+            it('should raise an error if we try to go back more than possible', function () {
+                expect(sock.rQshift32()).to.equal(0xabcd1234);
+                expect(() => sock.rQwait('hi', 8, 6)).to.throw(Error);
+            });
+
+            it('should not reduce rQi if there are enough bytes', function () {
+                expect(sock.rQshift32()).to.equal(0xabcd1234);
+                expect(sock.rQwait('hi', 4, 2)).to.be.false;
+                expect(sock.rQshift32()).to.equal(0x88ee1133);
+            });
+        });
+    });
+
+    describe('Send queue methods', function () {
+        let sock;
+
+        const bufferSize = 10 * 1024;
+
+        beforeEach(function () {
+            let websock = new FakeWebSocket();
+            websock._open();
+            sock = new Websock();
+            sock.attach(websock);
+        });
+
+        describe('sQpush8()', function () {
+            it('should send a single byte', function () {
+                sock.sQpush8(42);
+                sock.flush();
+                expect(sock).to.have.sent(new Uint8Array([42]));
+            });
+            it('should not send any data until flushing', function () {
+                sock.sQpush8(42);
+                expect(sock).to.have.sent(new Uint8Array([]));
+            });
+            it('should implicitly flush if the queue is full', function () {
+                for (let i = 0;i <= bufferSize;i++) {
+                    sock.sQpush8(42);
+                }
+
+                let expected = [];
+                for (let i = 0;i < bufferSize;i++) {
+                    expected.push(42);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+        });
+
+        describe('sQpush16()', function () {
+            it('should send a number as two bytes', function () {
+                sock.sQpush16(420);
+                sock.flush();
+                expect(sock).to.have.sent(new Uint8Array([1, 164]));
+            });
+            it('should not send any data until flushing', function () {
+                sock.sQpush16(420);
+                expect(sock).to.have.sent(new Uint8Array([]));
+            });
+            it('should implicitly flush if the queue is full', function () {
+                for (let i = 0;i <= bufferSize/2;i++) {
+                    sock.sQpush16(420);
+                }
+
+                let expected = [];
+                for (let i = 0;i < bufferSize/2;i++) {
+                    expected.push(1);
+                    expected.push(164);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+        });
+
+        describe('sQpush32()', function () {
+            it('should send a number as two bytes', function () {
+                sock.sQpush32(420420);
+                sock.flush();
+                expect(sock).to.have.sent(new Uint8Array([0, 6, 106, 68]));
+            });
+            it('should not send any data until flushing', function () {
+                sock.sQpush32(420420);
+                expect(sock).to.have.sent(new Uint8Array([]));
+            });
+            it('should implicitly flush if the queue is full', function () {
+                for (let i = 0;i <= bufferSize/4;i++) {
+                    sock.sQpush32(420420);
+                }
+
+                let expected = [];
+                for (let i = 0;i < bufferSize/4;i++) {
+                    expected.push(0);
+                    expected.push(6);
+                    expected.push(106);
+                    expected.push(68);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+        });
+
+        describe('sQpushString()', function () {
+            it('should send a string buffer', function () {
+                sock.sQpushString('\x12\x34\x56\x78\x90');
+                sock.flush();
+                expect(sock).to.have.sent(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90]));
+            });
+            it('should not send any data until flushing', function () {
+                sock.sQpushString('\x12\x34\x56\x78\x90');
+                expect(sock).to.have.sent(new Uint8Array([]));
+            });
+            it('should implicitly flush if the queue is full', function () {
+                for (let i = 0;i <= bufferSize/5;i++) {
+                    sock.sQpushString('\x12\x34\x56\x78\x90');
+                }
+
+                let expected = [];
+                for (let i = 0;i < bufferSize/5;i++) {
+                    expected.push(0x12);
+                    expected.push(0x34);
+                    expected.push(0x56);
+                    expected.push(0x78);
+                    expected.push(0x90);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+            it('should implicitly split a large buffer', function () {
+                let str = '';
+                for (let i = 0;i <= bufferSize/5;i++) {
+                    str += '\x12\x34\x56\x78\x90';
+                }
+
+                sock.sQpushString(str);
+
+                let expected = [];
+                for (let i = 0;i < bufferSize/5;i++) {
+                    expected.push(0x12);
+                    expected.push(0x34);
+                    expected.push(0x56);
+                    expected.push(0x78);
+                    expected.push(0x90);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+        });
+
+        describe('sQpushBytes()', function () {
+            it('should send a byte buffer', function () {
+                sock.sQpushBytes(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90]));
+                sock.flush();
+                expect(sock).to.have.sent(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90]));
+            });
+            it('should not send any data until flushing', function () {
+                sock.sQpushBytes(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90]));
+                expect(sock).to.have.sent(new Uint8Array([]));
+            });
+            it('should implicitly flush if the queue is full', function () {
+                for (let i = 0;i <= bufferSize/5;i++) {
+                    sock.sQpushBytes(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90]));
+                }
+
+                let expected = [];
+                for (let i = 0;i < bufferSize/5;i++) {
+                    expected.push(0x12);
+                    expected.push(0x34);
+                    expected.push(0x56);
+                    expected.push(0x78);
+                    expected.push(0x90);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+            it('should implicitly split a large buffer', function () {
+                let buffer = [];
+                for (let i = 0;i <= bufferSize/5;i++) {
+                    buffer.push(0x12);
+                    buffer.push(0x34);
+                    buffer.push(0x56);
+                    buffer.push(0x78);
+                    buffer.push(0x90);
+                }
+
+                sock.sQpushBytes(new Uint8Array(buffer));
+
+                let expected = [];
+                for (let i = 0;i < bufferSize/5;i++) {
+                    expected.push(0x12);
+                    expected.push(0x34);
+                    expected.push(0x56);
+                    expected.push(0x78);
+                    expected.push(0x90);
+                }
+
+                expect(sock).to.have.sent(new Uint8Array(expected));
+            });
+        });
+
+        describe('flush', function () {
+            it('should actually send on the websocket', function () {
+                sock._sQ = new Uint8Array([1, 2, 3]);
+                sock._sQlen = 3;
+
+                sock.flush();
+                expect(sock).to.have.sent(new Uint8Array([1, 2, 3]));
+            });
+
+            it('should not call send if we do not have anything queued up', function () {
+                sock._sQlen = 0;
+
+                sock.flush();
+
+                expect(sock).to.have.sent(new Uint8Array([]));
+            });
+        });
+    });
+
+    describe('lifecycle methods', function () {
+        let oldWS;
+        before(function () {
+            oldWS = WebSocket;
+        });
+
+        let sock;
+        beforeEach(function () {
+            sock = new Websock();
+            // eslint-disable-next-line no-global-assign
+            WebSocket = sinon.spy(FakeWebSocket);
+        });
+
+        describe('opening', function () {
+            it('should pick the correct protocols if none are given', function () {
+
+            });
+
+            it('should open the actual websocket', function () {
+                sock.open('ws://localhost:8675', 'binary');
+                expect(WebSocket).to.have.been.calledWith('ws://localhost:8675', 'binary');
+            });
+
+            // it('should initialize the event handlers')?
+        });
+
+        describe('attaching', function () {
+            it('should attach to an existing websocket', function () {
+                let ws = new FakeWebSocket('ws://localhost:8675');
+                sock.attach(ws);
+                expect(WebSocket).to.not.have.been.called;
+            });
+        });
+
+        describe('closing', function () {
+            beforeEach(function () {
+                sock.open('ws://localhost');
+                sock._websocket.close = sinon.spy();
+            });
+
+            it('should close the actual websocket if it is open', function () {
+                sock._websocket.readyState = WebSocket.OPEN;
+                sock.close();
+                expect(sock._websocket.close).to.have.been.calledOnce;
+            });
+
+            it('should close the actual websocket if it is connecting', function () {
+                sock._websocket.readyState = WebSocket.CONNECTING;
+                sock.close();
+                expect(sock._websocket.close).to.have.been.calledOnce;
+            });
+
+            it('should not try to close the actual websocket if closing', function () {
+                sock._websocket.readyState = WebSocket.CLOSING;
+                sock.close();
+                expect(sock._websocket.close).not.to.have.been.called;
+            });
+
+            it('should not try to close the actual websocket if closed', function () {
+                sock._websocket.readyState = WebSocket.CLOSED;
+                sock.close();
+                expect(sock._websocket.close).not.to.have.been.called;
+            });
+
+            it('should reset onmessage to not call _recvMessage', function () {
+                sinon.spy(sock, '_recvMessage');
+                sock.close();
+                sock._websocket.onmessage(null);
+                try {
+                    expect(sock._recvMessage).not.to.have.been.called;
+                } finally {
+                    sock._recvMessage.restore();
+                }
+            });
+        });
+
+        describe('event handlers', function () {
+            beforeEach(function () {
+                sock._recvMessage = sinon.spy();
+                sock.on('open', sinon.spy());
+                sock.on('close', sinon.spy());
+                sock.on('error', sinon.spy());
+                sock.open('ws://localhost');
+            });
+
+            it('should call _recvMessage on a message', function () {
+                sock._websocket.onmessage(null);
+                expect(sock._recvMessage).to.have.been.calledOnce;
+            });
+
+            it('should call the open event handler on opening', function () {
+                sock._websocket.onopen();
+                expect(sock._eventHandlers.open).to.have.been.calledOnce;
+            });
+
+            it('should call the close event handler on closing', function () {
+                sock._websocket.onclose();
+                expect(sock._eventHandlers.close).to.have.been.calledOnce;
+            });
+
+            it('should call the error event handler on error', function () {
+                sock._websocket.onerror();
+                expect(sock._eventHandlers.error).to.have.been.calledOnce;
+            });
+        });
+
+        describe('ready state', function () {
+            it('should be "unused" after construction', function () {
+                let sock = new Websock();
+                expect(sock.readyState).to.equal('unused');
+            });
+
+            it('should be "connecting" if WebSocket is connecting', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = WebSocket.CONNECTING;
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('connecting');
+            });
+
+            it('should be "open" if WebSocket is open', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = WebSocket.OPEN;
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('open');
+            });
+
+            it('should be "closing" if WebSocket is closing', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = WebSocket.CLOSING;
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('closing');
+            });
+
+            it('should be "closed" if WebSocket is closed', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = WebSocket.CLOSED;
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('closed');
+            });
+
+            it('should be "unknown" if WebSocket state is unknown', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = 666;
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('unknown');
+            });
+
+            it('should be "connecting" if RTCDataChannel is connecting', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = 'connecting';
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('connecting');
+            });
+
+            it('should be "open" if RTCDataChannel is open', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = 'open';
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('open');
+            });
+
+            it('should be "closing" if RTCDataChannel is closing', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = 'closing';
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('closing');
+            });
+
+            it('should be "closed" if RTCDataChannel is closed', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = 'closed';
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('closed');
+            });
+
+            it('should be "unknown" if RTCDataChannel state is unknown', function () {
+                let sock = new Websock();
+                let ws = new FakeWebSocket();
+                ws.readyState = 'foobar';
+                sock.attach(ws);
+                expect(sock.readyState).to.equal('unknown');
+            });
+        });
+
+        after(function () {
+            // eslint-disable-next-line no-global-assign
+            WebSocket = oldWS;
+        });
+    });
+
+    describe('WebSocket Receiving', function () {
+        let sock;
+        beforeEach(function () {
+            sock = new Websock();
+            sock._allocateBuffers();
+        });
+
+        it('should support adding data to the receive queue', function () {
+            const msg = { data: new Uint8Array([1, 2, 3]) };
+            sock._recvMessage(msg);
+            expect(sock.rQshiftStr(3)).to.equal('\x01\x02\x03');
+        });
+
+        it('should call the message event handler if present', function () {
+            sock._eventHandlers.message = sinon.spy();
+            const msg = { data: new Uint8Array([1, 2, 3]).buffer };
+            sock._mode = 'binary';
+            sock._recvMessage(msg);
+            expect(sock._eventHandlers.message).to.have.been.calledOnce;
+        });
+
+        it('should not call the message event handler if there is nothing in the receive queue', function () {
+            sock._eventHandlers.message = sinon.spy();
+            const msg = { data: new Uint8Array([]).buffer };
+            sock._mode = 'binary';
+            sock._recvMessage(msg);
+            expect(sock._eventHandlers.message).not.to.have.been.called;
+        });
+
+        it('should compact the receive queue when fully read', function () {
+            sock._rQ = new Uint8Array([0, 1, 2, 3, 4, 5, 0, 0, 0, 0]);
+            sock._rQlen = 6;
+            sock._rQi = 6;
+            const msg = { data: new Uint8Array([1, 2, 3]).buffer };
+            sock._recvMessage(msg);
+            expect(sock._rQlen).to.equal(3);
+            expect(sock._rQi).to.equal(0);
+        });
+
+        it('should compact the receive queue when we reach the end of the buffer', function () {
+            sock._rQ = new Uint8Array(20);
+            sock._rQbufferSize = 20;
+            sock._rQlen = 20;
+            sock._rQi = 10;
+            const msg = { data: new Uint8Array([1, 2]).buffer };
+            sock._recvMessage(msg);
+            expect(sock._rQlen).to.equal(12);
+            expect(sock._rQi).to.equal(0);
+        });
+
+        it('should automatically resize the receive queue if the incoming message is larger than the buffer', function () {
+            sock._rQ = new Uint8Array(20);
+            sock._rQlen = 0;
+            sock._rQi = 0;
+            sock._rQbufferSize = 20;
+            const msg = { data: new Uint8Array(30).buffer };
+            sock._recvMessage(msg);
+            expect(sock._rQlen).to.equal(30);
+            expect(sock._rQi).to.equal(0);
+            expect(sock._rQ.length).to.equal(240);  // keep the invariant that rQbufferSize / 8 >= rQlen
+        });
+
+        it('should automatically resize the receive queue if the incoming message is larger than 1/8th of the buffer and we reach the end of the buffer', function () {
+            sock._rQ = new Uint8Array(20);
+            sock._rQlen = 16;
+            sock._rQi = 15;
+            sock._rQbufferSize = 20;
+            const msg = { data: new Uint8Array(6).buffer };
+            sock._recvMessage(msg);
+            expect(sock._rQlen).to.equal(7);
+            expect(sock._rQi).to.equal(0);
+            expect(sock._rQ.length).to.equal(56);
+        });
+    });
+});

VM/novnc/tests/test.webutil.js

@@ -0,0 +1,240 @@
+/* jshint expr: true */
+
+const expect = chai.expect;
+
+import * as WebUtil from '../app/webutil.js';
+
+describe('WebUtil', function () {
+    "use strict";
+
+    describe('config variables', function () {
+        let origState, origHref;
+        beforeEach(function () {
+            origState = history.state;
+            origHref = location.href;
+        });
+        afterEach(function () {
+            history.replaceState(origState, '', origHref);
+        });
+
+        it('should parse query string variables', function () {
+            // history.pushState() will not cause the browser to attempt loading
+            // the URL, this is exactly what we want here for the tests.
+            history.replaceState({}, '', "test?myvar=myval");
+            expect(WebUtil.getConfigVar("myvar")).to.be.equal("myval");
+        });
+        it('should return default value when no query match', function () {
+            history.replaceState({}, '', "test?myvar=myval");
+            expect(WebUtil.getConfigVar("other", "def")).to.be.equal("def");
+        });
+        it('should handle no query match and no default value', function () {
+            history.replaceState({}, '', "test?myvar=myval");
+            expect(WebUtil.getConfigVar("other")).to.be.equal(null);
+        });
+        it('should parse fragment variables', function () {
+            history.replaceState({}, '', "test#myvar=myval");
+            expect(WebUtil.getConfigVar("myvar")).to.be.equal("myval");
+        });
+        it('should return default value when no fragment match', function () {
+            history.replaceState({}, '', "test#myvar=myval");
+            expect(WebUtil.getConfigVar("other", "def")).to.be.equal("def");
+        });
+        it('should handle no fragment match and no default value', function () {
+            history.replaceState({}, '', "test#myvar=myval");
+            expect(WebUtil.getConfigVar("other")).to.be.equal(null);
+        });
+        it('should handle both query and fragment', function () {
+            history.replaceState({}, '', "test?myquery=1#myhash=2");
+            expect(WebUtil.getConfigVar("myquery")).to.be.equal("1");
+            expect(WebUtil.getConfigVar("myhash")).to.be.equal("2");
+        });
+        it('should prioritize fragment if both provide same var', function () {
+            history.replaceState({}, '', "test?myvar=1#myvar=2");
+            expect(WebUtil.getConfigVar("myvar")).to.be.equal("2");
+        });
+    });
+
+    describe('cookies', function () {
+        // TODO
+    });
+
+    describe('settings', function () {
+
+        describe('localStorage', function () {
+            let chrome = window.chrome;
+            before(function () {
+                chrome = window.chrome;
+                window.chrome = null;
+            });
+            after(function () {
+                window.chrome = chrome;
+            });
+
+            let origLocalStorage;
+            beforeEach(function () {
+                origLocalStorage = Object.getOwnPropertyDescriptor(window, "localStorage");
+
+                Object.defineProperty(window, "localStorage", {value: {}});
+
+                window.localStorage.setItem = sinon.stub();
+                window.localStorage.getItem = sinon.stub();
+                window.localStorage.removeItem = sinon.stub();
+
+                return WebUtil.initSettings();
+            });
+            afterEach(function () {
+                Object.defineProperty(window, "localStorage", origLocalStorage);
+            });
+
+            describe('writeSetting', function () {
+                it('should save the setting value to local storage', function () {
+                    WebUtil.writeSetting('test', 'value');
+                    expect(window.localStorage.setItem).to.have.been.calledWithExactly('test', 'value');
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+
+                it('should not crash when local storage save fails', function () {
+                    localStorage.setItem.throws(new DOMException());
+                    expect(WebUtil.writeSetting('test', 'value')).to.not.throw;
+                });
+            });
+
+            describe('setSetting', function () {
+                it('should update the setting but not save to local storage', function () {
+                    WebUtil.setSetting('test', 'value');
+                    expect(window.localStorage.setItem).to.not.have.been.called;
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+            });
+
+            describe('readSetting', function () {
+                it('should read the setting value from local storage', function () {
+                    localStorage.getItem.returns('value');
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+
+                it('should return the default value when not in local storage', function () {
+                    expect(WebUtil.readSetting('test', 'default')).to.equal('default');
+                });
+
+                it('should return the cached value even if local storage changed', function () {
+                    localStorage.getItem.returns('value');
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                    localStorage.getItem.returns('something else');
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+
+                it('should cache the value even if it is not initially in local storage', function () {
+                    expect(WebUtil.readSetting('test')).to.be.null;
+                    localStorage.getItem.returns('value');
+                    expect(WebUtil.readSetting('test')).to.be.null;
+                });
+
+                it('should return the default value always if the first read was not in local storage', function () {
+                    expect(WebUtil.readSetting('test', 'default')).to.equal('default');
+                    localStorage.getItem.returns('value');
+                    expect(WebUtil.readSetting('test', 'another default')).to.equal('another default');
+                });
+
+                it('should return the last local written value', function () {
+                    localStorage.getItem.returns('value');
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                    WebUtil.writeSetting('test', 'something else');
+                    expect(WebUtil.readSetting('test')).to.equal('something else');
+                });
+
+                it('should not crash when local storage read fails', function () {
+                    localStorage.getItem.throws(new DOMException());
+                    expect(WebUtil.readSetting('test')).to.not.throw;
+                });
+            });
+
+            // this doesn't appear to be used anywhere
+            describe('eraseSetting', function () {
+                it('should remove the setting from local storage', function () {
+                    WebUtil.eraseSetting('test');
+                    expect(window.localStorage.removeItem).to.have.been.calledWithExactly('test');
+                });
+
+                it('should not crash when local storage remove fails', function () {
+                    localStorage.removeItem.throws(new DOMException());
+                    expect(WebUtil.eraseSetting('test')).to.not.throw;
+                });
+            });
+        });
+
+        describe('chrome.storage', function () {
+            let chrome = window.chrome;
+            let settings = {};
+            before(function () {
+                chrome = window.chrome;
+                window.chrome = {
+                    storage: {
+                        sync: {
+                            get(cb) { cb(settings); },
+                            set() {},
+                            remove() {}
+                        }
+                    }
+                };
+            });
+            after(function () {
+                window.chrome = chrome;
+            });
+
+            const csSandbox = sinon.createSandbox();
+
+            beforeEach(function () {
+                settings = {};
+                csSandbox.spy(window.chrome.storage.sync, 'set');
+                csSandbox.spy(window.chrome.storage.sync, 'remove');
+                return WebUtil.initSettings();
+            });
+            afterEach(function () {
+                csSandbox.restore();
+            });
+
+            describe('writeSetting', function () {
+                it('should save the setting value to chrome storage', function () {
+                    WebUtil.writeSetting('test', 'value');
+                    expect(window.chrome.storage.sync.set).to.have.been.calledWithExactly(sinon.match({ test: 'value' }));
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+            });
+
+            describe('setSetting', function () {
+                it('should update the setting but not save to chrome storage', function () {
+                    WebUtil.setSetting('test', 'value');
+                    expect(window.chrome.storage.sync.set).to.not.have.been.called;
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+            });
+
+            describe('readSetting', function () {
+                it('should read the setting value from chrome storage', function () {
+                    settings.test = 'value';
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                });
+
+                it('should return the default value when not in chrome storage', function () {
+                    expect(WebUtil.readSetting('test', 'default')).to.equal('default');
+                });
+
+                it('should return the last local written value', function () {
+                    settings.test = 'value';
+                    expect(WebUtil.readSetting('test')).to.equal('value');
+                    WebUtil.writeSetting('test', 'something else');
+                    expect(WebUtil.readSetting('test')).to.equal('something else');
+                });
+            });
+
+            // this doesn't appear to be used anywhere
+            describe('eraseSetting', function () {
+                it('should remove the setting from chrome storage', function () {
+                    WebUtil.eraseSetting('test');
+                    expect(window.chrome.storage.sync.remove).to.have.been.calledWithExactly('test');
+                });
+            });
+        });
+    });
+});

VM/novnc/tests/test.zrle.js

@@ -0,0 +1,144 @@
+const expect = chai.expect;
+
+import Websock from '../core/websock.js';
+import Display from '../core/display.js';
+
+import ZRLEDecoder from '../core/decoders/zrle.js';
+
+import FakeWebSocket from './fake.websocket.js';
+
+function testDecodeRect(decoder, x, y, width, height, data, display, depth) {
+    let sock;
+    let done = false;
+
+    sock = new Websock;
+    sock.open("ws://example.com");
+
+    sock.on('message', () => {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    });
+
+    // Empty messages are filtered at multiple layers, so we need to
+    // do a direct call
+    if (data.length === 0) {
+        done = decoder.decodeRect(x, y, width, height, sock, display, depth);
+    } else {
+        sock._websocket._receiveData(new Uint8Array(data));
+    }
+
+    display.flip();
+
+    return done;
+}
+
+describe('ZRLE Decoder', function () {
+    let decoder;
+    let display;
+
+    before(FakeWebSocket.replace);
+    after(FakeWebSocket.restore);
+
+    beforeEach(function () {
+        decoder = new ZRLEDecoder();
+        display = new Display(document.createElement('canvas'));
+        display.resize(4, 4);
+    });
+
+    it('should handle the Raw subencoding', function () {
+        let done = testDecodeRect(decoder, 0, 0, 4, 4,
+                                  [0x00, 0x00, 0x00, 0x0e, 0x78, 0x5e,
+                                   0x62, 0x60, 0x60, 0xf8, 0x4f, 0x12,
+                                   0x02, 0x00, 0x00, 0x00, 0xff, 0xff],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle the Solid subencoding', function () {
+        let done = testDecodeRect(decoder, 0, 0, 4, 4,
+                                  [0x00, 0x00, 0x00, 0x0c, 0x78, 0x5e,
+                                   0x62, 0x64, 0x60, 0xf8, 0x0f, 0x00,
+                                   0x00, 0x00, 0xff, 0xff],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+
+    it('should handle the Palette Tile subencoding', function () {
+        let done = testDecodeRect(decoder, 0, 0, 4, 4,
+                                  [0x00, 0x00, 0x00, 0x12, 0x78, 0x5E,
+                                   0x62, 0x62, 0x60,  248, 0xff, 0x9F,
+                                   0x01, 0x08, 0x3E, 0x7C, 0x00, 0x00,
+                                   0x00, 0x00, 0xff, 0xff],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff,
+            0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle the RLE Tile subencoding', function () {
+        let done = testDecodeRect(decoder, 0, 0, 4, 4,
+                                  [0x00, 0x00, 0x00, 0x0d, 0x78, 0x5e,
+                                   0x6a, 0x60, 0x60, 0xf8, 0x2f, 0x00,
+                                   0x00, 0x00, 0x00, 0xff, 0xff],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should handle the RLE Palette Tile subencoding', function () {
+        let done = testDecodeRect(decoder, 0, 0, 4, 4,
+                                  [0x00, 0x00, 0x00, 0x11, 0x78, 0x5e,
+                                   0x6a, 0x62, 0x60, 0xf8, 0xff, 0x9f,
+                                   0x81, 0xa1, 0x81, 0x1f, 0x00, 0x00,
+                                   0x00, 0xff, 0xff],
+                                  display, 24);
+
+        let targetData = new Uint8Array([
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff
+        ]);
+
+        expect(done).to.be.true;
+        expect(display).to.have.displayed(targetData);
+    });
+
+    it('should fail on an invalid subencoding', function () {
+        let data = [0x00, 0x00, 0x00, 0x0c, 0x78, 0x5e, 0x6a, 0x64, 0x60, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0xff, 0xff];
+        expect(() => testDecodeRect(decoder, 0, 0, 4, 4, data, display, 24)).to.throw();
+    });
+});

VM/novnc/tests/vnc_playback.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <title>VNC Playback</title>
+        <script type="module" src="./playback-ui.js"></script>
+    </head>
+    <body>
+
+        Iterations: <input id='iterations'>&nbsp;
+        Perftest:<input type='radio' id='mode1' name='mode' checked>&nbsp;
+        Realtime:<input type='radio' id='mode2' name='mode'>&nbsp;&nbsp;
+
+        <input id='startButton' type='button' value='Start' disabled>&nbsp;
+
+        <br><br>
+
+        Results:<br>
+        <textarea id="messages" cols=80 rows=25></textarea>
+
+        <br><br>
+
+        <div id="VNC_screen">
+            <div id="VNC_status">Loading</div>
+        </div>
+    </body>
+</html>