Merge branch 'master' into testing

author: Alex Yatskov <alex@foosoft.net> 2020-04-10 09:38:07 -0700
committer: Alex Yatskov <alex@foosoft.net> 2020-04-10 09:38:07 -0700
commit: 3ed49205f2af076e3c5b4fe371d8a0a420845581 (patch)
tree: ab0c0fd9638aaa6a842bc4f17e73754ca7d26bd9 /test
parent: b77e2afe3a8ef9e96a53dd8ca97d8b913941244b (diff)
parent: 281023095a9fb7f7aca1df8dc0e3f902e78dc16b (diff)
10 files changed, 1234 insertions, 11 deletions
diff --git a/test/data/dictionaries/valid-dictionary1/tag_bank_3.json b/test/data/dictionaries/valid-dictionary1/tag_bank_3.json
new file mode 100644
index 00000000..572221fe
--- /dev/null
+++ b/test/data/dictionaries/valid-dictionary1/tag_bank_3.json
@@ -0,0 +1,4 @@
+[
+    ["ptag1", "pcategory1", 0, "ptag1 notes", 0],
+    ["ptag2", "pcategory2", 0, "ptag2 notes", 0]
+]
+\ No newline at end of file
diff --git a/test/data/dictionaries/valid-dictionary1/term_meta_bank_1.json b/test/data/dictionaries/valid-dictionary1/term_meta_bank_1.json
index 78096502..26922394 100644
--- a/test/data/dictionaries/valid-dictionary1/term_meta_bank_1.json
+++ b/test/data/dictionaries/valid-dictionary1/term_meta_bank_1.json
@@ -1,5 +1,39 @@
 [
     ["打", "freq", 1],
     ["打つ", "freq", 2],
-    ["打ち込む", "freq", 3]
+    ["打ち込む", "freq", 3],
+    [
+        "打ち込む",
+        "pitch",
+        {
+            "reading": "うちこむ",
+            "pitches": [
+                {"position": 0},
+                {"position": 3}
+            ]
+        }
+    ],
+    [
+        "打ち込む",
+        "pitch",
+        {
+            "reading": "ぶちこむ",
+            "pitches": [
+                {"position": 0},
+                {"position": 3}
+            ]
+        }
+    ],
+    [
+        "お手前",
+        "pitch",
+        {
+            "reading": "おてまえ",
+            "pitches": [
+                {"position": 2, "tags": ["ptag1"]},
+                {"position": 2, "tags": ["ptag2"]},
+                {"position": 0, "tags": ["ptag2"]}
+            ]
+        }
+    ]
 ]
 \ No newline at end of file
diff --git a/test/data/html/test-document2-frame1.html b/test/data/html/test-document2-frame1.html
new file mode 100644
index 00000000..3b85cdc5
--- /dev/null
+++ b/test/data/html/test-document2-frame1.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <title>Yomichan Tests</title>
+        <script src="test-document2-script.js"></script>
+        <style>
+body {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 14px;
+    padding: 0;
+    margin: 0;
+    background-color: #f8f8f8;
+}
+a, a:visited {
+    color: #1080c0;
+    text-decoration: underline;
+}
+.content {
+    position: absolute;
+    left: 0;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    padding: 0.5em;
+    background-color: #f8f8f8;
+}
+        </style>
+    </head>
+<body><div class="content">
+<div>
+    ありがとう
+</div>
+<div>
+    <a href="#" id="fullscreen-link">Toggle fullscreen</a>
+    <script>
+document.querySelector('#fullscreen-link').addEventListener('click', () => toggleFullscreen(document.body), false);
+    </script>
+</div>
+</div></body>
+</html>
+\ No newline at end of file
diff --git a/test/data/html/test-document2-script.js b/test/data/html/test-document2-script.js
new file mode 100644
index 00000000..bd5a570d
--- /dev/null
+++ b/test/data/html/test-document2-script.js
@@ -0,0 +1,41 @@
+function requestFullscreen(element) {
+    if (element.requestFullscreen) {
+        element.requestFullscreen();
+    } else if (element.mozRequestFullScreen) {
+        element.mozRequestFullScreen();
+    } else if (element.webkitRequestFullscreen) {
+        element.webkitRequestFullscreen();
+    } else if (element.msRequestFullscreen) {
+        element.msRequestFullscreen();
+    }
+}
+
+function exitFullscreen() {
+    if (document.exitFullscreen) {
+        document.exitFullscreen();
+    } else if (document.mozCancelFullScreen) {
+        document.mozCancelFullScreen();
+    } else if (document.webkitExitFullscreen) {
+        document.webkitExitFullscreen();
+    } else if (document.msExitFullscreen) {
+        document.msExitFullscreen();
+    }
+}
+
+function getFullscreenElement() {
+    return (
+        document.fullscreenElement ||
+        document.msFullscreenElement ||
+        document.mozFullScreenElement ||
+        document.webkitFullscreenElement ||
+        null
+    );
+}
+
+function toggleFullscreen(element) {
+    if (getFullscreenElement()) {
+        exitFullscreen();
+    } else {
+        requestFullscreen(element);
+    }
+}
diff --git a/test/data/html/test-document2.html b/test/data/html/test-document2.html
new file mode 100644
index 00000000..3a22a5bf
--- /dev/null
+++ b/test/data/html/test-document2.html
@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <title>Yomichan Manual Tests</title>
+        <link rel="icon" type="image/gif" href="data:image/gif;base64,R0lGODlhEAAQAKEBAAAAAP///////////yH5BAEKAAIALAAAAAAQABAAAAImFI6Zpt0B4YkS0TCpq07xbmEgcGVRUpLaI46ZG7ppalY0jDCwUAAAOw==" />
+        <link rel="stylesheet" href="test-stylesheet.css" />
+        <script src="test-document2-script.js"></script>
+    </head>
+<body>
+
+    <h1>Yomichan Manual Tests</h1>
+    <p class="description">Manual tests involving fullscreen elements, &lt;iframe&gt;s, and shadow DOMs.</p>
+
+    <div class="test">
+        <div class="description">Standard content.</div>
+        <div id="fullscreen-element1" style="width: 100%; height: 200px; border: 1px solid #d8d8d8; position: relative;"><div style="background-color: #f8f8f8; padding: 0.5em; position: absolute; left: 0; top: 0; bottom: 0; right: 0;">
+            <div>
+                ありがとう
+            </div>
+            <div>
+                <a href="#" id="fullscreen-link1">Toggle fullscreen</a>
+            </div>
+        </div></div>
+        <script>
+document.querySelector('#fullscreen-link1').addEventListener('click', () => toggleFullscreen(document.querySelector('#fullscreen-element1')), false);
+        </script>
+    </div>
+
+    <div class="test">
+        <div class="description">Content inside of a shadow DOM.</div>
+        <div id="shadow-content-container"></div>
+        <template id="shadow-content-container-content-template">
+            <link rel="stylesheet" href="test-stylesheet.css" />
+            <div id="fullscreen-element2" style="width: 100%; height: 200px; border: 1px solid #d8d8d8; position: relative;"><div style="background-color: #f8f8f8; padding: 0.5em; position: absolute; left: 0; top: 0; bottom: 0; right: 0;">
+                <div>
+                    ありがとう
+                </div>
+                <div>
+                    <a href="#" id="fullscreen-link2">Toggle fullscreen</a>
+                </div>
+            </div></div>
+        </template>
+        <script>
+(() => {
+    const shadowIframeContainer = document.querySelector('#shadow-content-container');
+    const shadow = shadowIframeContainer.attachShadow({mode: 'closed'});
+    const template = document.querySelector('#shadow-content-container-content-template').content;
+    const content = document.importNode(template, true);
+    const fullscreenElement = content.querySelector('#fullscreen-element2');
+    content.querySelector('#fullscreen-link2').addEventListener('click', () => toggleFullscreen(fullscreenElement), false);
+    shadow.appendChild(content);
+})();
+        </script>
+    </div>
+
+    <div class="test">
+        <div class="description">&lt;iframe&gt; element.</div>
+        <iframe src="test-document2-frame1.html" allowfullscreen="true" style="width: 100%; height: 200px; border: 1px solid #d8d8d8;"></iframe>
+    </div>
+
+    <div class="test">
+        <div class="description">&lt;iframe&gt; element inside of a shadow DOM.</div>
+        <div id="shadow-iframe-container"></div>
+        <template id="shadow-iframe-container-content-template">
+            <iframe src="test-document2-frame1.html" allowfullscreen="true" style="width: 100%; height: 200px; border: 1px solid #d8d8d8;"></iframe>
+        </template>
+        <script>
+(() => {
+    const shadowIframeContainer = document.querySelector('#shadow-iframe-container');
+    const shadow = shadowIframeContainer.attachShadow({mode: 'closed'});
+    const template = document.querySelector('#shadow-iframe-container-content-template').content;
+    const content = document.importNode(template, true);
+    shadow.appendChild(content);
+})();
+        </script>
+    </div>
+
+</body>
+</html>
+\ No newline at end of file
diff --git a/test/data/html/test-stylesheet.css b/test/data/html/test-stylesheet.css
index ab25732e..f63d2481 100644
--- a/test/data/html/test-stylesheet.css
+++ b/test/data/html/test-stylesheet.css
@@ -7,6 +7,7 @@ body {
     margin: 0 auto;
     background-color: #f8f8f8;
     counter-reset: test-id;
+    overflow-y: scroll;
 }
 
 h1 {
@@ -14,6 +15,19 @@ h1 {
     margin: 0.67em 0;
 }
 
+p {
+    margin: 0.33em 0;
+}
+
+h1+p {
+    margin-top: -0.67em;
+}
+
+a, a:visited {
+    color: #1080c0;
+    text-decoration: underline;
+}
+
 .test {
     background-color: #ffffff;
     margin: 1em 0;
@@ -30,3 +44,8 @@ h1 {
     border-bottom: 1px solid #d8d8d8;
     font-weight: bold;
 }
+
+.description {
+    color: #444444;
+    font-style: italic;
+}
diff --git a/test/test-database.js b/test/test-database.js
index 833aa75d..bab15aa4 100644
--- a/test/test-database.js
+++ b/test/test-database.js
@@ -27,7 +27,8 @@ require('fake-indexeddb/auto');
 const chrome = {
     runtime: {
         onMessage: {
-            addListener() { /* NOP */ }
+            addListener() { /* NOP */ },
+            removeListener() { /* NOP */ }
         },
         getURL(path2) {
             return url.pathToFileURL(path.join(__dirname, '..', 'ext', path2.replace(/^\//, '')));
@@ -107,8 +108,10 @@ vm.execute([
     'bg/js/dictionary.js',
     'mixed/js/core.js',
     'bg/js/request.js',
+    'bg/js/dictionary-importer.js',
     'bg/js/database.js'
 ]);
+const DictionaryImporter = vm.get('DictionaryImporter');
 const Database = vm.get('Database');
 
 
@@ -196,6 +199,7 @@ async function testDatabase1() {
     ];
 
     // Setup database
+    const dictionaryImporter = new DictionaryImporter();
     const database = new Database();
     await database.prepare();
 
@@ -210,7 +214,8 @@ async function testDatabase1() {
 
         // Import data
         let progressEvent = false;
-        const {result, errors} = await database.importDictionary(
+        const {result, errors} = await dictionaryImporter.import(
+            database,
             testDictionarySource,
             () => {
                 progressEvent = true;
@@ -231,8 +236,8 @@ async function testDatabase1() {
             true
         );
         vm.assert.deepStrictEqual(counts, {
-            counts: [{kanji: 2, kanjiMeta: 2, terms: 32, termMeta: 3, tagMeta: 12}],
-            total: {kanji: 2, kanjiMeta: 2, terms: 32, termMeta: 3, tagMeta: 12}
+            counts: [{kanji: 2, kanjiMeta: 2, terms: 32, termMeta: 6, tagMeta: 14}],
+            total: {kanji: 2, kanjiMeta: 2, terms: 32, termMeta: 6, tagMeta: 14}
         });
 
         // Test find* functions
@@ -648,9 +653,10 @@ async function testFindTermMetaBulk1(database, titles) {
                 }
             ],
             expectedResults: {
-                total: 1,
+                total: 3,
                 modes: [
-                    ['freq', 1]
+                    ['freq', 1],
+                    ['pitch', 2]
                 ]
             }
         },
@@ -847,6 +853,7 @@ async function testDatabase2() {
     ]);
 
     // Setup database
+    const dictionaryImporter = new DictionaryImporter();
     const database = new Database();
 
     // Error: not prepared
@@ -862,17 +869,17 @@ async function testDatabase2() {
     await assert.rejects(async () => await database.findTagForTitle('tag', title));
     await assert.rejects(async () => await database.getDictionaryInfo());
     await assert.rejects(async () => await database.getDictionaryCounts(titles, true));
-    await assert.rejects(async () => await database.importDictionary(testDictionarySource, () => {}, {}));
+    await assert.rejects(async () => await dictionaryImporter.import(database, testDictionarySource, () => {}, {}));
 
     await database.prepare();
 
     // Error: already prepared
     await assert.rejects(async () => await database.prepare());
 
-    await database.importDictionary(testDictionarySource, () => {}, {});
+    await dictionaryImporter.import(database, testDictionarySource, () => {}, {});
 
     // Error: dictionary already imported
-    await assert.rejects(async () => await database.importDictionary(testDictionarySource, () => {}, {}));
+    await assert.rejects(async () => await dictionaryImporter.import(database, testDictionarySource, () => {}, {}));
 
     await database.close();
 }
@@ -889,6 +896,7 @@ async function testDatabase3() {
     ];
 
     // Setup database
+    const dictionaryImporter = new DictionaryImporter();
     const database = new Database();
     await database.prepare();
 
@@ -898,7 +906,7 @@ async function testDatabase3() {
 
         let error = null;
         try {
-            await database.importDictionary(testDictionarySource, () => {}, {});
+            await dictionaryImporter.import(database, testDictionarySource, () => {}, {});
         } catch (e) {
             error = e;
         }
diff --git a/test/test-japanese.js b/test/test-japanese.js
new file mode 100644
index 00000000..ca65dde2
--- /dev/null
+++ b/test/test-japanese.js
@@ -0,0 +1,471 @@
+/*
+ * 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 assert = require('assert');
+const {VM} = require('./yomichan-vm');
+
+const vm = new VM();
+vm.execute([
+    'mixed/lib/wanakana.min.js',
+    'mixed/js/japanese.js',
+    'bg/js/text-source-map.js',
+    'bg/js/japanese.js'
+]);
+const jp = vm.get('jp');
+const TextSourceMap = vm.get('TextSourceMap');
+
+
+function testIsCodePointKanji() {
+    const data = [
+        ['力方', true],
+        ['\u53f1\u{20b9f}', true],
+        ['かたカタ々kata、。？,.?', false]
+    ];
+
+    for (const [characters, expected] of data) {
+        for (const character of characters) {
+            const codePoint = character.codePointAt(0);
+            const actual = jp.isCodePointKanji(codePoint);
+            assert.strictEqual(actual, expected, `isCodePointKanji failed for ${character} (\\u{${codePoint.toString(16)}})`);
+        }
+    }
+}
+
+function testIsCodePointKana() {
+    const data = [
+        ['かたカタ', true],
+        ['力方々kata、。？,.?', false],
+        ['\u53f1\u{20b9f}', false]
+    ];
+
+    for (const [characters, expected] of data) {
+        for (const character of characters) {
+            const codePoint = character.codePointAt(0);
+            const actual = jp.isCodePointKana(codePoint);
+            assert.strictEqual(actual, expected, `isCodePointKana failed for ${character} (\\u{${codePoint.toString(16)}})`);
+        }
+    }
+}
+
+function testIsCodePointJapanese() {
+    const data = [
+        ['かたカタ力方々、。？', true],
+        ['\u53f1\u{20b9f}', true],
+        ['kata,.?', false]
+    ];
+
+    for (const [characters, expected] of data) {
+        for (const character of characters) {
+            const codePoint = character.codePointAt(0);
+            const actual = jp.isCodePointJapanese(codePoint);
+            assert.strictEqual(actual, expected, `isCodePointJapanese failed for ${character} (\\u{${codePoint.toString(16)}})`);
+        }
+    }
+}
+
+function testIsStringEntirelyKana() {
+    const data = [
+        ['かたかな', true],
+        ['カタカナ', true],
+        ['ひらがな', true],
+        ['ヒラガナ', true],
+        ['カタカナひらがな', true],
+        ['かたカタ力方々、。？', false],
+        ['\u53f1\u{20b9f}', false],
+        ['kata,.?', false],
+        ['かたカタ力方々、。？invalid', false],
+        ['\u53f1\u{20b9f}invalid', false],
+        ['kata,.?かた', false]
+    ];
+
+    for (const [string, expected] of data) {
+        assert.strictEqual(jp.isStringEntirelyKana(string), expected);
+    }
+}
+
+function testIsStringPartiallyJapanese() {
+    const data = [
+        ['かたかな', true],
+        ['カタカナ', true],
+        ['ひらがな', true],
+        ['ヒラガナ', true],
+        ['カタカナひらがな', true],
+        ['かたカタ力方々、。？', true],
+        ['\u53f1\u{20b9f}', true],
+        ['kata,.?', false],
+        ['かたカタ力方々、。？invalid', true],
+        ['\u53f1\u{20b9f}invalid', true],
+        ['kata,.?かた', true]
+    ];
+
+    for (const [string, expected] of data) {
+        assert.strictEqual(jp.isStringPartiallyJapanese(string), expected);
+    }
+}
+
+function testConvertKatakanaToHiragana() {
+    const data = [
+        ['かたかな', 'かたかな'],
+        ['ひらがな', 'ひらがな'],
+        ['カタカナ', 'かたかな'],
+        ['ヒラガナ', 'ひらがな'],
+        ['カタカナかたかな', 'かたかなかたかな'],
+        ['ヒラガナひらがな', 'ひらがなひらがな'],
+        ['chikaraちからチカラ力', 'chikaraちからちから力'],
+        ['katakana', 'katakana'],
+        ['hiragana', 'hiragana']
+    ];
+
+    for (const [string, expected] of data) {
+        assert.strictEqual(jp.convertKatakanaToHiragana(string), expected);
+    }
+}
+
+function testConvertHiraganaToKatakana() {
+    const data = [
+        ['かたかな', 'カタカナ'],
+        ['ひらがな', 'ヒラガナ'],
+        ['カタカナ', 'カタカナ'],
+        ['ヒラガナ', 'ヒラガナ'],
+        ['カタカナかたかな', 'カタカナカタカナ'],
+        ['ヒラガナひらがな', 'ヒラガナヒラガナ'],
+        ['chikaraちからチカラ力', 'chikaraチカラチカラ力'],
+        ['katakana', 'katakana'],
+        ['hiragana', 'hiragana']
+    ];
+
+    for (const [string, expected] of data) {
+        assert.strictEqual(jp.convertHiraganaToKatakana(string), expected);
+    }
+}
+
+function testConvertToRomaji() {
+    const data = [
+        ['かたかな', 'katakana'],
+        ['ひらがな', 'hiragana'],
+        ['カタカナ', 'katakana'],
+        ['ヒラガナ', 'hiragana'],
+        ['カタカナかたかな', 'katakanakatakana'],
+        ['ヒラガナひらがな', 'hiraganahiragana'],
+        ['chikaraちからチカラ力', 'chikarachikarachikara力'],
+        ['katakana', 'katakana'],
+        ['hiragana', 'hiragana']
+    ];
+
+    for (const [string, expected] of data) {
+        assert.strictEqual(jp.convertToRomaji(string), expected);
+    }
+}
+
+function testConvertReading() {
+    const data = [
+        [['アリガトウ', 'アリガトウ', 'hiragana'], 'ありがとう'],
+        [['アリガトウ', 'アリガトウ', 'katakana'], 'アリガトウ'],
+        [['アリガトウ', 'アリガトウ', 'romaji'], 'arigatou'],
+        [['アリガトウ', 'アリガトウ', 'none'], null],
+        [['アリガトウ', 'アリガトウ', 'default'], 'アリガトウ'],
+
+        [['ありがとう', 'ありがとう', 'hiragana'], 'ありがとう'],
+        [['ありがとう', 'ありがとう', 'katakana'], 'アリガトウ'],
+        [['ありがとう', 'ありがとう', 'romaji'], 'arigatou'],
+        [['ありがとう', 'ありがとう', 'none'], null],
+        [['ありがとう', 'ありがとう', 'default'], 'ありがとう'],
+
+        [['有り難う', 'ありがとう', 'hiragana'], 'ありがとう'],
+        [['有り難う', 'ありがとう', 'katakana'], 'アリガトウ'],
+        [['有り難う', 'ありがとう', 'romaji'], 'arigatou'],
+        [['有り難う', 'ありがとう', 'none'], null],
+        [['有り難う', 'ありがとう', 'default'], 'ありがとう'],
+
+        // Cases with falsy readings
+
+        [['ありがとう', '', 'hiragana'], ''],
+        [['ありがとう', '', 'katakana'], ''],
+        [['ありがとう', '', 'romaji'], 'arigatou'],
+        [['ありがとう', '', 'none'], null],
+        [['ありがとう', '', 'default'], ''],
+
+        [['ありがとう', null, 'hiragana'], ''],
+        [['ありがとう', null, 'katakana'], ''],
+        [['ありがとう', null, 'romaji'], 'arigatou'],
+        [['ありがとう', null, 'none'], null],
+        [['ありがとう', null, 'default'], null],
+
+        [['ありがとう', void 0, 'hiragana'], ''],
+        [['ありがとう', void 0, 'katakana'], ''],
+        [['ありがとう', void 0, 'romaji'], 'arigatou'],
+        [['ありがとう', void 0, 'none'], null],
+        [['ありがとう', void 0, 'default'], void 0],
+
+        // Cases with falsy readings and kanji expressions
+
+        [['有り難う', '', 'hiragana'], ''],
+        [['有り難う', '', 'katakana'], ''],
+        [['有り難う', '', 'romaji'], ''],
+        [['有り難う', '', 'none'], null],
+        [['有り難う', '', 'default'], ''],
+
+        [['有り難う', null, 'hiragana'], ''],
+        [['有り難う', null, 'katakana'], ''],
+        [['有り難う', null, 'romaji'], null],
+        [['有り難う', null, 'none'], null],
+        [['有り難う', null, 'default'], null],
+
+        [['有り難う', void 0, 'hiragana'], ''],
+        [['有り難う', void 0, 'katakana'], ''],
+        [['有り難う', void 0, 'romaji'], void 0],
+        [['有り難う', void 0, 'none'], null],
+        [['有り難う', void 0, 'default'], void 0]
+    ];
+
+    for (const [[expressionFragment, readingFragment, readingMode], expected] of data) {
+        assert.strictEqual(jp.convertReading(expressionFragment, readingFragment, readingMode), expected);
+    }
+}
+
+function testConvertNumericToFullWidth() {
+    const data = [
+        ['0123456789', '０１２３４５６７８９'],
+        ['abcdefghij', 'abcdefghij'],
+        ['カタカナ', 'カタカナ'],
+        ['ひらがな', 'ひらがな']
+    ];
+
+    for (const [string, expected] of data) {
+        assert.strictEqual(jp.convertNumericToFullWidth(string), expected);
+    }
+}
+
+function testConvertHalfWidthKanaToFullWidth() {
+    const data = [
+        ['0123456789', '0123456789'],
+        ['abcdefghij', 'abcdefghij'],
+        ['カタカナ', 'カタカナ'],
+        ['ひらがな', 'ひらがな'],
+        ['ｶｷ', 'カキ', [1, 1]],
+        ['ｶﾞｷ', 'ガキ', [2, 1]],
+        ['ﾆﾎﾝ', 'ニホン', [1, 1, 1]],
+        ['ﾆｯﾎﾟﾝ', 'ニッポン', [1, 1, 2, 1]]
+    ];
+
+    for (const [string, expected, expectedSourceMapping] of data) {
+        const sourceMap = new TextSourceMap(string);
+        const actual1 = jp.convertHalfWidthKanaToFullWidth(string, null);
+        const actual2 = jp.convertHalfWidthKanaToFullWidth(string, sourceMap);
+        assert.strictEqual(actual1, expected);
+        assert.strictEqual(actual2, expected);
+        if (typeof expectedSourceMapping !== 'undefined') {
+            assert.ok(sourceMap.equals(new TextSourceMap(string, expectedSourceMapping)));
+        }
+    }
+}
+
+function testConvertAlphabeticToKana() {
+    const data = [
+        ['0123456789', '0123456789'],
+        ['abcdefghij', 'あbcでfgひj', [1, 1, 1, 2, 1, 1, 2, 1]],
+        ['ABCDEFGHIJ', 'あbcでfgひj', [1, 1, 1, 2, 1, 1, 2, 1]], // wanakana.toHiragana converts text to lower case
+        ['カタカナ', 'カタカナ'],
+        ['ひらがな', 'ひらがな'],
+        ['chikara', 'ちから', [3, 2, 2]],
+        ['CHIKARA', 'ちから', [3, 2, 2]]
+    ];
+
+    for (const [string, expected, expectedSourceMapping] of data) {
+        const sourceMap = new TextSourceMap(string);
+        const actual1 = jp.convertAlphabeticToKana(string, null);
+        const actual2 = jp.convertAlphabeticToKana(string, sourceMap);
+        assert.strictEqual(actual1, expected);
+        assert.strictEqual(actual2, expected);
+        if (typeof expectedSourceMapping !== 'undefined') {
+            assert.ok(sourceMap.equals(new TextSourceMap(string, expectedSourceMapping)));
+        }
+    }
+}
+
+function testDistributeFurigana() {
+    const data = [
+        [
+            ['有り難う', 'ありがとう'],
+            [
+                {text: '有', furigana: 'あ'},
+                {text: 'り'},
+                {text: '難', furigana: 'がと'},
+                {text: 'う'}
+            ]
+        ],
+        [
+            ['方々', 'かたがた'],
+            [
+                {text: '方々', furigana: 'かたがた'}
+            ]
+        ],
+        [
+            ['お祝い', 'おいわい'],
+            [
+                {text: 'お'},
+                {text: '祝', furigana: 'いわ'},
+                {text: 'い'}
+            ]
+        ],
+        [
+            ['美味しい', 'おいしい'],
+            [
+                {text: '美味', furigana: 'おい'},
+                {text: 'しい'}
+            ]
+        ],
+        [
+            ['食べ物', 'たべもの'],
+            [
+                {text: '食', furigana: 'た'},
+                {text: 'べ'},
+                {text: '物', furigana: 'もの'}
+            ]
+        ],
+        [
+            ['試し切り', 'ためしぎり'],
+            [
+                {text: '試', furigana: 'ため'},
+                {text: 'し'},
+                {text: '切', furigana: 'ぎ'},
+                {text: 'り'}
+            ]
+        ],
+        // Ambiguous
+        [
+            ['飼い犬', 'かいいぬ'],
+            [
+                {text: '飼い犬', furigana: 'かいいぬ'}
+            ]
+        ],
+        [
+            ['長い間', 'ながいあいだ'],
+            [
+                {text: '長い間', furigana: 'ながいあいだ'}
+            ]
+        ]
+    ];
+
+    for (const [[expression, reading], expected] of data) {
+        const actual = jp.distributeFurigana(expression, reading);
+        vm.assert.deepStrictEqual(actual, expected);
+    }
+}
+
+function testDistributeFuriganaInflected() {
+    const data = [
+        [
+            ['美味しい', 'おいしい', '美味しかた'],
+            [
+                {text: '美味', furigana: 'おい'},
+                {text: 'し'},
+                {text: 'かた'}
+            ]
+        ],
+        [
+            ['食べる', 'たべる', '食べた'],
+            [
+                {text: '食', furigana: 'た'},
+                {text: 'べ'},
+                {text: 'た'}
+            ]
+        ]
+    ];
+
+    for (const [[expression, reading, source], expected] of data) {
+        const actual = jp.distributeFuriganaInflected(expression, reading, source);
+        vm.assert.deepStrictEqual(actual, expected);
+    }
+}
+
+function testIsMoraPitchHigh() {
+    const data = [
+        [[0, 0], false],
+        [[1, 0], true],
+        [[2, 0], true],
+        [[3, 0], true],
+
+        [[0, 1], true],
+        [[1, 1], false],
+        [[2, 1], false],
+        [[3, 1], false],
+
+        [[0, 2], true],
+        [[1, 2], true],
+        [[2, 2], false],
+        [[3, 2], false],
+
+        [[0, 3], true],
+        [[1, 3], true],
+        [[2, 3], true],
+        [[3, 3], false],
+
+        [[0, 4], true],
+        [[1, 4], true],
+        [[2, 4], true],
+        [[3, 4], true]
+    ];
+
+    for (const [[moraIndex, pitchAccentPosition], expected] of data) {
+        const actual = jp.isMoraPitchHigh(moraIndex, pitchAccentPosition);
+        assert.strictEqual(actual, expected);
+    }
+}
+
+function testGetKanaMorae() {
+    const data = [
+        ['かこ', ['か', 'こ']],
+        ['かっこ', ['か', 'っ', 'こ']],
+        ['カコ', ['カ', 'コ']],
+        ['カッコ', ['カ', 'ッ', 'コ']],
+        ['コート', ['コ', 'ー', 'ト']],
+        ['ちゃんと', ['ちゃ', 'ん', 'と']],
+        ['とうきょう', ['と', 'う', 'きょ', 'う']],
+        ['ぎゅう', ['ぎゅ', 'う']],
+        ['ディスコ', ['ディ', 'ス', 'コ']]
+    ];
+
+    for (const [text, expected] of data) {
+        const actual = jp.getKanaMorae(text);
+        vm.assert.deepStrictEqual(actual, expected);
+    }
+}
+
+
+function main() {
+    testIsCodePointKanji();
+    testIsCodePointKana();
+    testIsCodePointJapanese();
+    testIsStringEntirelyKana();
+    testIsStringPartiallyJapanese();
+    testConvertKatakanaToHiragana();
+    testConvertHiraganaToKatakana();
+    testConvertToRomaji();
+    testConvertReading();
+    testConvertNumericToFullWidth();
+    testConvertHalfWidthKanaToFullWidth();
+    testConvertAlphabeticToKana();
+    testDistributeFurigana();
+    testDistributeFuriganaInflected();
+    testIsMoraPitchHigh();
+    testGetKanaMorae();
+}
+
+
+if (require.main === module) { main(); }
diff --git a/test/test-object-property-accessor.js b/test/test-object-property-accessor.js
new file mode 100644
index 00000000..47d2e451
--- /dev/null
+++ b/test/test-object-property-accessor.js
@@ -0,0 +1,289 @@
+/*
+ * 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 assert = require('assert');
+const {VM} = require('./yomichan-vm');
+
+const vm = new VM({});
+vm.execute('mixed/js/object-property-accessor.js');
+const ObjectPropertyAccessor = vm.get('ObjectPropertyAccessor');
+
+
+function createTestObject() {
+    return {
+        0: null,
+        value1: {
+            value2: {},
+            value3: [],
+            value4: null
+        },
+        value5: [
+            {},
+            [],
+            null
+        ]
+    };
+}
+
+
+function testGetProperty1() {
+    const object = createTestObject();
+    const accessor = new ObjectPropertyAccessor(object);
+
+    const data = [
+        [[], object],
+        [['0'], object['0']],
+        [['value1'], object.value1],
+        [['value1', 'value2'], object.value1.value2],
+        [['value1', 'value3'], object.value1.value3],
+        [['value1', 'value4'], object.value1.value4],
+        [['value5'], object.value5],
+        [['value5', 0], object.value5[0]],
+        [['value5', 1], object.value5[1]],
+        [['value5', 2], object.value5[2]]
+    ];
+
+    for (const [pathArray, expected] of data) {
+        assert.strictEqual(accessor.getProperty(pathArray), expected);
+    }
+}
+
+function testGetProperty2() {
+    const object = createTestObject();
+    const accessor = new ObjectPropertyAccessor(object);
+
+    const data = [
+        [[0], 'Invalid path: [0]'],
+        [['0', 'invalid'], 'Invalid path: ["0"].invalid'],
+        [['invalid'], 'Invalid path: invalid'],
+        [['value1', 'invalid'], 'Invalid path: value1.invalid'],
+        [['value1', 'value2', 'invalid'], 'Invalid path: value1.value2.invalid'],
+        [['value1', 'value2', 0], 'Invalid path: value1.value2[0]'],
+        [['value1', 'value3', 'invalid'], 'Invalid path: value1.value3.invalid'],
+        [['value1', 'value3', 0], 'Invalid path: value1.value3[0]'],
+        [['value1', 'value4', 'invalid'], 'Invalid path: value1.value4.invalid'],
+        [['value1', 'value4', 0], 'Invalid path: value1.value4[0]'],
+        [['value5', 'length'], 'Invalid path: value5.length'],
+        [['value5', 0, 'invalid'], 'Invalid path: value5[0].invalid'],
+        [['value5', 0, 0], 'Invalid path: value5[0][0]'],
+        [['value5', 1, 'invalid'], 'Invalid path: value5[1].invalid'],
+        [['value5', 1, 0], 'Invalid path: value5[1][0]'],
+        [['value5', 2, 'invalid'], 'Invalid path: value5[2].invalid'],
+        [['value5', 2, 0], 'Invalid path: value5[2][0]'],
+        [['value5', 2, 0, 'invalid'], 'Invalid path: value5[2][0]'],
+        [['value5', 2.5], 'Invalid index']
+    ];
+
+    for (const [pathArray, message] of data) {
+        assert.throws(() => accessor.getProperty(pathArray), {message});
+    }
+}
+
+
+function testSetProperty1() {
+    const object = createTestObject();
+    const accessor = new ObjectPropertyAccessor(object);
+
+    const testValue = {};
+    const data = [
+        ['0'],
+        ['value1', 'value2'],
+        ['value1', 'value3'],
+        ['value1', 'value4'],
+        ['value1'],
+        ['value5', 0],
+        ['value5', 1],
+        ['value5', 2],
+        ['value5']
+    ];
+
+    for (const pathArray of data) {
+        accessor.setProperty(pathArray, testValue);
+        assert.strictEqual(accessor.getProperty(pathArray), testValue);
+    }
+}
+
+function testSetProperty2() {
+    const object = createTestObject();
+    const accessor = new ObjectPropertyAccessor(object);
+
+    const testValue = {};
+    const data = [
+        [[0], 'Invalid path: [0]'],
+        [['0', 'invalid'], 'Invalid path: ["0"].invalid'],
+        [['value1', 'value2', 0], 'Invalid path: value1.value2[0]'],
+        [['value1', 'value3', 'invalid'], 'Invalid path: value1.value3.invalid'],
+        [['value1', 'value4', 'invalid'], 'Invalid path: value1.value4.invalid'],
+        [['value1', 'value4', 0], 'Invalid path: value1.value4[0]'],
+        [['value5', 1, 'invalid'], 'Invalid path: value5[1].invalid'],
+        [['value5', 2, 'invalid'], 'Invalid path: value5[2].invalid'],
+        [['value5', 2, 0], 'Invalid path: value5[2][0]'],
+        [['value5', 2, 0, 'invalid'], 'Invalid path: value5[2][0]'],
+        [['value5', 2.5], 'Invalid index']
+    ];
+
+    for (const [pathArray, message] of data) {
+        assert.throws(() => accessor.setProperty(pathArray, testValue), {message});
+    }
+}
+
+
+function testGetPathString1() {
+    const data = [
+        [[], ''],
+        [[0], '[0]'],
+        [['escape\\'], '["escape\\\\"]'],
+        [['\'quote\''], '["\'quote\'"]'],
+        [['"quote"'], '["\\"quote\\""]'],
+        [['part1', 'part2'], 'part1.part2'],
+        [['part1', 'part2', 3], 'part1.part2[3]'],
+        [['part1', 'part2', '3'], 'part1.part2["3"]'],
+        [['part1', 'part2', '3part'], 'part1.part2["3part"]'],
+        [['part1', 'part2', '3part', 'part4'], 'part1.part2["3part"].part4'],
+        [['part1', 'part2', '3part', '4part'], 'part1.part2["3part"]["4part"]']
+    ];
+
+    for (const [pathArray, expected] of data) {
+        assert.strictEqual(ObjectPropertyAccessor.getPathString(pathArray), expected);
+    }
+}
+
+function testGetPathString2() {
+    const data = [
+        [[1.5], 'Invalid index'],
+        [[null], 'Invalid type: object']
+    ];
+
+    for (const [pathArray, message] of data) {
+        assert.throws(() => ObjectPropertyAccessor.getPathString(pathArray), {message});
+    }
+}
+
+
+function testGetPathArray1() {
+    const data = [
+        ['', []],
+        ['[0]', [0]],
+        ['["escape\\\\"]', ['escape\\']],
+        ['["\'quote\'"]', ['\'quote\'']],
+        ['["\\"quote\\""]', ['"quote"']],
+        ['part1.part2', ['part1', 'part2']],
+        ['part1.part2[3]', ['part1', 'part2', 3]],
+        ['part1.part2["3"]', ['part1', 'part2', '3']],
+        ['part1.part2[\'3\']', ['part1', 'part2', '3']],
+        ['part1.part2["3part"]', ['part1', 'part2', '3part']],
+        ['part1.part2[\'3part\']', ['part1', 'part2', '3part']],
+        ['part1.part2["3part"].part4', ['part1', 'part2', '3part', 'part4']],
+        ['part1.part2[\'3part\'].part4', ['part1', 'part2', '3part', 'part4']],
+        ['part1.part2["3part"]["4part"]', ['part1', 'part2', '3part', '4part']],
+        ['part1.part2[\'3part\'][\'4part\']', ['part1', 'part2', '3part', '4part']]
+    ];
+
+    for (const [pathString, expected] of data) {
+        vm.assert.deepStrictEqual(ObjectPropertyAccessor.getPathArray(pathString), expected);
+    }
+}
+
+function testGetPathArray2() {
+    const data = [
+        ['?', 'Unexpected character: ?'],
+        ['.', 'Unexpected character: .'],
+        ['0', 'Unexpected character: 0'],
+        ['part1.[0]', 'Unexpected character: ['],
+        ['part1?', 'Unexpected character: ?'],
+        ['[part1]', 'Unexpected character: p'],
+        ['[0a]', 'Unexpected character: a'],
+        ['["part1"x]', 'Unexpected character: x'],
+        ['[\'part1\'x]', 'Unexpected character: x'],
+        ['["part1"]x', 'Unexpected character: x'],
+        ['[\'part1\']x', 'Unexpected character: x'],
+        ['part1..part2', 'Unexpected character: .'],
+
+        ['[', 'Path not terminated correctly'],
+        ['part1.', 'Path not terminated correctly'],
+        ['part1[', 'Path not terminated correctly'],
+        ['part1["', 'Path not terminated correctly'],
+        ['part1[\'', 'Path not terminated correctly'],
+        ['part1[""', 'Path not terminated correctly'],
+        ['part1[\'\'', 'Path not terminated correctly'],
+        ['part1[0', 'Path not terminated correctly'],
+        ['part1[0].', 'Path not terminated correctly']
+    ];
+
+    for (const [pathString, message] of data) {
+        assert.throws(() => ObjectPropertyAccessor.getPathArray(pathString), {message});
+    }
+}
+
+
+function testHasProperty() {
+    const data = [
+        [{}, 'invalid', false],
+        [{}, 0, false],
+        [{valid: 0}, 'valid', true],
+        [{null: 0}, null, false],
+        [[], 'invalid', false],
+        [[], 0, false],
+        [[0], 0, true],
+        [[0], null, false],
+        ['string', 0, false],
+        ['string', 'length', false],
+        ['string', null, false]
+    ];
+
+    for (const [object, property, expected] of data) {
+        assert.strictEqual(ObjectPropertyAccessor.hasProperty(object, property), expected);
+    }
+}
+
+function testIsValidPropertyType() {
+    const data = [
+        [{}, 'invalid', true],
+        [{}, 0, false],
+        [{valid: 0}, 'valid', true],
+        [{null: 0}, null, false],
+        [[], 'invalid', false],
+        [[], 0, true],
+        [[0], 0, true],
+        [[0], null, false],
+        ['string', 0, false],
+        ['string', 'length', false],
+        ['string', null, false]
+    ];
+
+    for (const [object, property, expected] of data) {
+        assert.strictEqual(ObjectPropertyAccessor.isValidPropertyType(object, property), expected);
+    }
+}
+
+
+function main() {
+    testGetProperty1();
+    testGetProperty2();
+    testSetProperty1();
+    testSetProperty2();
+    testGetPathString1();
+    testGetPathString2();
+    testGetPathArray1();
+    testGetPathArray2();
+    testHasProperty();
+    testIsValidPropertyType();
+}
+
+
+if (require.main === module) { main(); }
diff --git a/test/test-text-source-map.js b/test/test-text-source-map.js
new file mode 100644
index 00000000..25bd8fc2
--- /dev/null
+++ b/test/test-text-source-map.js
@@ -0,0 +1,234 @@
+/*
+ * 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 assert = require('assert');
+const {VM} = require('./yomichan-vm');
+
+const vm = new VM();
+vm.execute(['bg/js/text-source-map.js']);
+const TextSourceMap = vm.get('TextSourceMap');
+
+
+function testSource() {
+    const data = [
+        ['source1'],
+        ['source2'],
+        ['source3']
+    ];
+
+    for (const [source] of data) {
+        const sourceMap = new TextSourceMap(source);
+        assert.strictEqual(source, sourceMap.source);
+    }
+}
+
+function testEquals() {
+    const data = [
+        [['source1', null], ['source1', null], true],
+        [['source2', null], ['source2', null], true],
+        [['source3', null], ['source3', null], true],
+
+        [['source1', [1, 1, 1, 1, 1, 1, 1]], ['source1', null], true],
+        [['source2', [1, 1, 1, 1, 1, 1, 1]], ['source2', null], true],
+        [['source3', [1, 1, 1, 1, 1, 1, 1]], ['source3', null], true],
+
+        [['source1', null], ['source1', [1, 1, 1, 1, 1, 1, 1]], true],
+        [['source2', null], ['source2', [1, 1, 1, 1, 1, 1, 1]], true],
+        [['source3', null], ['source3', [1, 1, 1, 1, 1, 1, 1]], true],
+
+        [['source1', [1, 1, 1, 1, 1, 1, 1]], ['source1', [1, 1, 1, 1, 1, 1, 1]], true],
+        [['source2', [1, 1, 1, 1, 1, 1, 1]], ['source2', [1, 1, 1, 1, 1, 1, 1]], true],
+        [['source3', [1, 1, 1, 1, 1, 1, 1]], ['source3', [1, 1, 1, 1, 1, 1, 1]], true],
+
+        [['source1', [1, 2, 1, 3]], ['source1', [1, 2, 1, 3]], true],
+        [['source2', [1, 2, 1, 3]], ['source2', [1, 2, 1, 3]], true],
+        [['source3', [1, 2, 1, 3]], ['source3', [1, 2, 1, 3]], true],
+
+        [['source1', [1, 3, 1, 2]], ['source1', [1, 2, 1, 3]], false],
+        [['source2', [1, 3, 1, 2]], ['source2', [1, 2, 1, 3]], false],
+        [['source3', [1, 3, 1, 2]], ['source3', [1, 2, 1, 3]], false],
+
+        [['source1', [1, 1, 1, 1, 1, 1, 1]], ['source4', [1, 1, 1, 1, 1, 1, 1]], false],
+        [['source2', [1, 1, 1, 1, 1, 1, 1]], ['source5', [1, 1, 1, 1, 1, 1, 1]], false],
+        [['source3', [1, 1, 1, 1, 1, 1, 1]], ['source6', [1, 1, 1, 1, 1, 1, 1]], false]
+    ];
+
+    for (const [[source1, mapping1], [source2, mapping2], expectedEquals] of data) {
+        const sourceMap1 = new TextSourceMap(source1, mapping1);
+        const sourceMap2 = new TextSourceMap(source2, mapping2);
+        assert.ok(sourceMap1.equals(sourceMap1));
+        assert.ok(sourceMap2.equals(sourceMap2));
+        assert.strictEqual(sourceMap1.equals(sourceMap2), expectedEquals);
+    }
+}
+
+function testGetSourceLength() {
+    const data = [
+        [['source', [1, 1, 1, 1, 1, 1]], 1, 1],
+        [['source', [1, 1, 1, 1, 1, 1]], 2, 2],
+        [['source', [1, 1, 1, 1, 1, 1]], 3, 3],
+        [['source', [1, 1, 1, 1, 1, 1]], 4, 4],
+        [['source', [1, 1, 1, 1, 1, 1]], 5, 5],
+        [['source', [1, 1, 1, 1, 1, 1]], 6, 6],
+
+        [['source', [2, 2, 2]], 1, 2],
+        [['source', [2, 2, 2]], 2, 4],
+        [['source', [2, 2, 2]], 3, 6],
+
+        [['source', [3, 3]], 1, 3],
+        [['source', [3, 3]], 2, 6],
+
+        [['source', [6, 6]], 1, 6]
+    ];
+
+    for (const [[source, mapping], finalLength, expectedValue] of data) {
+        const sourceMap = new TextSourceMap(source, mapping);
+        assert.strictEqual(sourceMap.getSourceLength(finalLength), expectedValue);
+    }
+}
+
+function testCombineInsert() {
+    const data = [
+        // No operations
+        [
+            ['source', null],
+            ['source', [1, 1, 1, 1, 1, 1]],
+            []
+        ],
+
+        // Combine
+        [
+            ['source', null],
+            ['source', [3, 1, 1, 1]],
+            [
+                ['combine', 0, 2]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [1, 1, 1, 3]],
+            [
+                ['combine', 3, 2]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [3, 3]],
+            [
+                ['combine', 0, 2],
+                ['combine', 1, 2]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [3, 3]],
+            [
+                ['combine', 3, 2],
+                ['combine', 0, 2]
+            ]
+        ],
+
+        // Insert
+        [
+            ['source', null],
+            ['source', [0, 1, 1, 1, 1, 1, 1]],
+            [
+                ['insert', 0, 0]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [1, 1, 1, 1, 1, 1, 0]],
+            [
+                ['insert', 6, 0]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [0, 1, 1, 1, 1, 1, 1, 0]],
+            [
+                ['insert', 0, 0],
+                ['insert', 7, 0]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [0, 1, 1, 1, 1, 1, 1, 0]],
+            [
+                ['insert', 6, 0],
+                ['insert', 0, 0]
+            ]
+        ],
+
+        // Mixed
+        [
+            ['source', null],
+            ['source', [3, 0, 3]],
+            [
+                ['combine', 0, 2],
+                ['insert', 1, 0],
+                ['combine', 2, 2]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [3, 0, 3]],
+            [
+                ['combine', 0, 2],
+                ['combine', 1, 2],
+                ['insert', 1, 0]
+            ]
+        ],
+        [
+            ['source', null],
+            ['source', [3, 0, 3]],
+            [
+                ['insert', 3, 0],
+                ['combine', 0, 2],
+                ['combine', 2, 2]
+            ]
+        ]
+    ];
+
+    for (const [[source, mapping], [expectedSource, expectedMapping], operations] of data) {
+        const sourceMap = new TextSourceMap(source, mapping);
+        const expectedSourceMap = new TextSourceMap(expectedSource, expectedMapping);
+        for (const [operation, ...args] of operations) {
+            switch (operation) {
+                case 'combine':
+                    sourceMap.combine(...args);
+                    break;
+                case 'insert':
+                    sourceMap.insert(...args);
+                    break;
+            }
+        }
+        assert.ok(sourceMap.equals(expectedSourceMap));
+    }
+}
+
+
+function main() {
+    testSource();
+    testEquals();
+    testGetSourceLength();
+    testCombineInsert();
+}
+
+
+if (require.main === module) { main(); }
author	Alex Yatskov <alex@foosoft.net>	2020-04-10 09:38:07 -0700
committer	Alex Yatskov <alex@foosoft.net>	2020-04-10 09:38:07 -0700
commit	3ed49205f2af076e3c5b4fe371d8a0a420845581 (patch)
tree	ab0c0fd9638aaa6a842bc4f17e73754ca7d26bd9 /test
parent	b77e2afe3a8ef9e96a53dd8ca97d8b913941244b (diff)
parent	281023095a9fb7f7aca1df8dc0e3f902e78dc16b (diff)