Merge branch 'master' into testing

1 files changed, 240 insertions, 0 deletions

diff --git a/test/test-document.js b/test/test-document.js
new file mode 100644
index 00000000..80b9719d
--- /dev/null
+++ b/test/test-document.js
@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2020  Alex Yatskov <alex@foosoft.net>
+ * Author: Alex Yatskov <alex@foosoft.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const {JSDOM} = require('jsdom');
+const {VM} = require('./yomichan-vm');
+
+
+// DOMRect class definition
+class DOMRect {
+    constructor(x, y, width, height) {
+        this._x = x;
+        this._y = y;
+        this._width = width;
+        this._height = height;
+    }
+
+    get x() { return this._x; }
+    get y() { return this._y; }
+    get width() { return this._width; }
+    get height() { return this._height; }
+    get left() { return this._x + Math.min(0, this._width); }
+    get right() { return this._x + Math.max(0, this._width); }
+    get top() { return this._y + Math.min(0, this._height); }
+    get bottom() { return this._y + Math.max(0, this._height); }
+}
+
+
+function createJSDOM(fileName) {
+    const domSource = fs.readFileSync(fileName, {encoding: 'utf8'});
+    const dom = new JSDOM(domSource);
+    const document = dom.window.document;
+    const window = dom.window;
+
+    // Define innerText setter as an alias for textContent setter
+    Object.defineProperty(window.HTMLDivElement.prototype, 'innerText', {
+        set(value) { this.textContent = value; }
+    });
+
+    // Placeholder for feature detection
+    document.caretRangeFromPoint = () => null;
+
+    return dom;
+}
+
+function querySelectorChildOrSelf(element, selector) {
+    return selector ? element.querySelector(selector) : element;
+}
+
+function getChildTextNodeOrSelf(dom, node) {
+    if (node === null) { return null; }
+    const Node = dom.window.Node;
+    const childNode = node.firstChild;
+    return (childNode !== null && childNode.nodeType === Node.TEXT_NODE ? childNode : node);
+}
+
+function getPrototypeOfOrNull(value) {
+    try {
+        return Object.getPrototypeOf(value);
+    } catch (e) {
+        return null;
+    }
+}
+
+function findImposterElement(document) {
+    // Finds the imposter element based on it's z-index style
+    return document.querySelector('div[style*="2147483646"]>*');
+}
+
+
+async function testDocument1() {
+    const dom = createJSDOM(path.join(__dirname, 'data', 'html', 'test-document1.html'));
+    const window = dom.window;
+    const document = window.document;
+    const Node = window.Node;
+    const Range = window.Range;
+
+    const vm = new VM({document, window, Range, Node});
+    vm.execute([
+        'mixed/js/dom.js',
+        'fg/js/source.js',
+        'fg/js/document.js'
+    ]);
+    const [TextSourceRange, TextSourceElement, docRangeFromPoint, docSentenceExtract] = vm.get([
+        'TextSourceRange',
+        'TextSourceElement',
+        'docRangeFromPoint',
+        'docSentenceExtract'
+    ]);
+
+    try {
+        await testDocumentTextScanningFunctions(dom, {docRangeFromPoint, docSentenceExtract, TextSourceRange, TextSourceElement});
+        await testTextSourceRangeSeekFunctions(dom, {TextSourceRange});
+    } finally {
+        window.close();
+    }
+}
+
+async function testDocumentTextScanningFunctions(dom, {docRangeFromPoint, docSentenceExtract, TextSourceRange, TextSourceElement}) {
+    const document = dom.window.document;
+
+    for (const testElement of document.querySelectorAll('.test[data-test-type=scan]')) {
+        // Get test parameters
+        let {
+            elementFromPointSelector,
+            caretRangeFromPointSelector,
+            startNodeSelector,
+            startOffset,
+            endNodeSelector,
+            endOffset,
+            resultType,
+            sentenceExtent,
+            sentence,
+            hasImposter
+        } = testElement.dataset;
+
+        const elementFromPointValue = querySelectorChildOrSelf(testElement, elementFromPointSelector);
+        const caretRangeFromPointValue = querySelectorChildOrSelf(testElement, caretRangeFromPointSelector);
+        const startNode = getChildTextNodeOrSelf(dom, querySelectorChildOrSelf(testElement, startNodeSelector));
+        const endNode = getChildTextNodeOrSelf(dom, querySelectorChildOrSelf(testElement, endNodeSelector));
+
+        startOffset = parseInt(startOffset, 10);
+        endOffset = parseInt(endOffset, 10);
+        sentenceExtent = parseInt(sentenceExtent, 10);
+
+        assert.notStrictEqual(elementFromPointValue, null);
+        assert.notStrictEqual(caretRangeFromPointValue, null);
+        assert.notStrictEqual(startNode, null);
+        assert.notStrictEqual(endNode, null);
+
+        // Setup functions
+        document.elementFromPoint = () => elementFromPointValue;
+
+        document.caretRangeFromPoint = (x, y) => {
+            const imposter = getChildTextNodeOrSelf(dom, findImposterElement(document));
+            assert.strictEqual(!!imposter, hasImposter === 'true');
+
+            const range = document.createRange();
+            range.setStart(imposter ? imposter : startNode, startOffset);
+            range.setEnd(imposter ? imposter : startNode, endOffset);
+
+            // Override getClientRects to return a rect guaranteed to contain (x, y)
+            range.getClientRects = () => [new DOMRect(x - 1, y - 1, 2, 2)];
+            return range;
+        };
+
+        // Test docRangeFromPoint
+        const source = docRangeFromPoint(0, 0, false);
+        switch (resultType) {
+            case 'TextSourceRange':
+                assert.strictEqual(getPrototypeOfOrNull(source), TextSourceRange.prototype);
+                break;
+            case 'TextSourceElement':
+                assert.strictEqual(getPrototypeOfOrNull(source), TextSourceElement.prototype);
+                break;
+            case 'null':
+                assert.strictEqual(source, null);
+                break;
+            default:
+                assert.ok(false);
+                break;
+        }
+        if (source === null) { continue; }
+
+        // Test docSentenceExtract
+        const sentenceActual = docSentenceExtract(source, sentenceExtent).text;
+        assert.strictEqual(sentenceActual, sentence);
+
+        // Clean
+        source.cleanup();
+    }
+}
+
+async function testTextSourceRangeSeekFunctions(dom, {TextSourceRange}) {
+    const document = dom.window.document;
+
+    for (const testElement of document.querySelectorAll('.test[data-test-type=text-source-range-seek]')) {
+        // Get test parameters
+        let {
+            seekNodeSelector,
+            seekNodeIsText,
+            seekOffset,
+            seekLength,
+            seekDirection,
+            expectedResultNodeSelector,
+            expectedResultNodeIsText,
+            expectedResultOffset,
+            expectedResultContent
+        } = testElement.dataset;
+
+        seekOffset = parseInt(seekOffset, 10);
+        seekLength = parseInt(seekLength, 10);
+        expectedResultOffset = parseInt(expectedResultOffset, 10);
+
+        let seekNode = testElement.querySelector(seekNodeSelector);
+        if (seekNodeIsText === 'true') {
+            seekNode = seekNode.firstChild;
+        }
+
+        let expectedResultNode = testElement.querySelector(expectedResultNodeSelector);
+        if (expectedResultNodeIsText === 'true') {
+            expectedResultNode = expectedResultNode.firstChild;
+        }
+
+        const {node, offset, content} = (
+            seekDirection === 'forward' ?
+            TextSourceRange.seekForward(seekNode, seekOffset, seekLength) :
+            TextSourceRange.seekBackward(seekNode, seekOffset, seekLength)
+        );
+
+        assert.strictEqual(node, expectedResultNode);
+        assert.strictEqual(offset, expectedResultOffset);
+        assert.strictEqual(content, expectedResultContent);
+    }
+}
+
+
+async function main() {
+    await testDocument1();
+}
+
+
+if (require.main === module) { main(); }