Test updates (#501)

* update tests

* japanese-util updates

* update json-schema tests

7 files changed, 261 insertions, 166 deletions

diff --git a/test/cache-map.test.js b/test/cache-map.test.js
index 9db30677..5db35cf0 100644
--- a/test/cache-map.test.js
+++ b/test/cache-map.test.js
@@ -18,35 +18,27 @@
 
 /* eslint-disable no-multi-spaces */
 
-import {expect, test} from 'vitest';
+import {describe, expect, test} from 'vitest';
 import {CacheMap} from '../ext/js/general/cache-map.js';
 
 /** */
 function testConstructor() {
-    test('constructor', () => {
-        const data = [
-            [false, () => new CacheMap(0)],
-            [false, () => new CacheMap(1)],
-            [false, () => new CacheMap(Number.MAX_VALUE)],
-            [true,  () => new CacheMap(-1)],
-            [true,  () => new CacheMap(1.5)],
-            [true,  () => new CacheMap(Number.NaN)],
-            [true,  () => new CacheMap(Number.POSITIVE_INFINITY)]
-        ];
+    describe('constructor', () => {
+        const shouldThrow = [-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY];
+        const shouldNotThrow = [0, 1, Number.MAX_VALUE];
 
-        for (const [throws, create] of data) {
-            if (throws) {
-                expect(create).toThrowError();
-            } else {
-                expect(create).not.toThrowError();
-            }
-        }
+        test.each(shouldNotThrow)('`() => new CacheMap(%d)` should not throw', (param) => {
+            expect(() => new CacheMap(param)).not.toThrowError();
+        });
+        test.each(shouldThrow)('`() => new CacheMap(%d)` should throw', (param) => {
+            expect(() => new CacheMap(param)).toThrowError();
+        });
     });
 }
 
 /** */
 function testApi() {
-    test('api', () => {
+    describe('api', () => {
         const data = [
             {
                 maxSize: 1,
@@ -99,7 +91,7 @@ function testApi() {
             }
         ];
 
-        for (const {maxSize, expectedSize, calls} of data) {
+        test.each(data)('api-test-%#', ({maxSize, expectedSize, calls}) => {
             const cache = new CacheMap(maxSize);
             expect(cache.maxSize).toStrictEqual(maxSize);
             for (const call of calls) {
@@ -117,7 +109,7 @@ function testApi() {
                 }
             }
             expect(cache.size).toStrictEqual(expectedSize);
-        }
+        });
     });
 }
 
diff --git a/test/core.test.js b/test/core.test.js
index 685bf9dc..127df783 100644
--- a/test/core.test.js
+++ b/test/core.test.js
@@ -21,11 +21,11 @@ import {DynamicProperty, deepEqual} from '../ext/js/core.js';
 
 /** */
 function testDynamicProperty() {
-    test('DynamicProperty', () => {
+    describe('DynamicProperty', () => {
+        /** @type {import('test/core').DynamicPropertyTestData} */
         const data = [
             {
                 initialValue: 0,
-                /** @type {{operation: ?string, expectedDefaultValue: number, expectedValue: number, expectedOverrideCount: number, expeectedEventOccurred: boolean, args: [value: number, priority?: number]}[]} */
                 operations: [
                     {
                         operation: null,
@@ -33,7 +33,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 0,
                         expectedOverrideCount: 0,
-                        expeectedEventOccurred: false
+                        expectedEventOccurred: false
                     },
                     {
                         operation: 'set.defaultValue',
@@ -41,7 +41,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 1,
                         expectedValue: 1,
                         expectedOverrideCount: 0,
-                        expeectedEventOccurred: true
+                        expectedEventOccurred: true
                     },
                     {
                         operation: 'set.defaultValue',
@@ -49,7 +49,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 1,
                         expectedValue: 1,
                         expectedOverrideCount: 0,
-                        expeectedEventOccurred: false
+                        expectedEventOccurred: false
                     },
                     {
                         operation: 'set.defaultValue',
@@ -57,7 +57,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 0,
                         expectedOverrideCount: 0,
-                        expeectedEventOccurred: true
+                        expectedEventOccurred: true
                     },
                     {
                         operation: 'setOverride',
@@ -65,7 +65,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 8,
                         expectedOverrideCount: 1,
-                        expeectedEventOccurred: true
+                        expectedEventOccurred: true
                     },
                     {
                         operation: 'setOverride',
@@ -73,7 +73,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 8,
                         expectedOverrideCount: 2,
-                        expeectedEventOccurred: false
+                        expectedEventOccurred: false
                     },
                     {
                         operation: 'setOverride',
@@ -81,7 +81,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 32,
                         expectedOverrideCount: 3,
-                        expeectedEventOccurred: true
+                        expectedEventOccurred: true
                     },
                     {
                         operation: 'setOverride',
@@ -89,7 +89,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 32,
                         expectedOverrideCount: 4,
-                        expeectedEventOccurred: false
+                        expectedEventOccurred: false
                     },
                     {
                         operation: 'clearOverride',
@@ -97,7 +97,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 32,
                         expectedOverrideCount: 3,
-                        expeectedEventOccurred: false
+                        expectedEventOccurred: false
                     },
                     {
                         operation: 'clearOverride',
@@ -105,7 +105,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 32,
                         expectedOverrideCount: 2,
-                        expeectedEventOccurred: false
+                        expectedEventOccurred: false
                     },
                     {
                         operation: 'clearOverride',
@@ -113,7 +113,7 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 64,
                         expectedOverrideCount: 1,
-                        expeectedEventOccurred: true
+                        expectedEventOccurred: true
                     },
                     {
                         operation: 'clearOverride',
@@ -121,40 +121,42 @@ function testDynamicProperty() {
                         expectedDefaultValue: 0,
                         expectedValue: 0,
                         expectedOverrideCount: 0,
-                        expeectedEventOccurred: true
+                        expectedEventOccurred: true
                     }
                 ]
             }
         ];
 
-        for (const {initialValue, operations} of data) {
-            const property = new DynamicProperty(initialValue);
-            const overrideTokens = [];
-            let eventOccurred = false;
-            const onChange = () => { eventOccurred = true; };
-            property.on('change', onChange);
-            for (const {operation, args, expectedDefaultValue, expectedValue, expectedOverrideCount, expeectedEventOccurred} of operations) {
-                eventOccurred = false;
-                switch (operation) {
-                    case 'set.defaultValue': property.defaultValue = args[0]; break;
-                    case 'setOverride': overrideTokens.push(property.setOverride(...args)); break;
-                    case 'clearOverride': property.clearOverride(overrideTokens[overrideTokens.length + args[0]]); break;
+        describe.each(data)('Test DynamicProperty($initialValue)', ({initialValue, operations}) => {
+            test('works as expected', () => {
+                const property = new DynamicProperty(initialValue);
+                const overrideTokens = [];
+                let eventOccurred = false;
+                const onChange = () => { eventOccurred = true; };
+                property.on('change', onChange);
+                for (const {operation, args, expectedDefaultValue, expectedValue, expectedOverrideCount, expectedEventOccurred} of operations) {
+                    eventOccurred = false;
+                    switch (operation) {
+                        case 'set.defaultValue': property.defaultValue = args[0]; break;
+                        case 'setOverride': overrideTokens.push(property.setOverride(...args)); break;
+                        case 'clearOverride': property.clearOverride(overrideTokens[overrideTokens.length + args[0]]); break;
+                    }
+                    expect(eventOccurred).toStrictEqual(expectedEventOccurred);
+                    expect(property.defaultValue).toStrictEqual(expectedDefaultValue);
+                    expect(property.value).toStrictEqual(expectedValue);
+                    expect(property.overrideCount).toStrictEqual(expectedOverrideCount);
                 }
-                expect(eventOccurred).toStrictEqual(expeectedEventOccurred);
-                expect(property.defaultValue).toStrictEqual(expectedDefaultValue);
-                expect(property.value).toStrictEqual(expectedValue);
-                expect(property.overrideCount).toStrictEqual(expectedOverrideCount);
-            }
-            property.off('change', onChange);
-        }
+                property.off('change', onChange);
+            });
+        });
     });
 }
 
 /** */
 function testDeepEqual() {
     describe('deepEqual', () => {
-        const data = [
-        // Simple tests
+        /** @type {import('test/core').DeepEqualTestData} */
+        const simpleTestsData = [
             {
                 value1: 0,
                 value2: 0,
@@ -194,9 +196,10 @@ function testDeepEqual() {
                 value1: true,
                 value2: false,
                 expected: false
-            },
-
-            // Simple object tests
+            }
+        ];
+        /** @type {import('test/core').DeepEqualTestData} */
+        const simpleObjectTestsData = [
             {
                 value1: {},
                 value2: {},
@@ -216,9 +219,10 @@ function testDeepEqual() {
                 value1: {},
                 value2: null,
                 expected: false
-            },
-
-            // Complex object tests
+            }
+        ];
+        /** @type {import('test/core').DeepEqualTestData} */
+        const complexObjectTestsData = [
             {
                 value1: [1],
                 value2: [],
@@ -259,27 +263,55 @@ function testDeepEqual() {
                 value1: {test: {test2: [true]}},
                 value2: {test: {test2: [true]}},
                 expected: true
-            },
-
-            // Recursive
+            }
+        ];
+        /** @type {import('test/core').DeepEqualTestData} */
+        const recursiveTestsData = [
             {
                 value1: (() => { const x = {}; x.x = x; return x; })(),
                 value2: (() => { const x = {}; x.x = x; return x; })(),
                 expected: false
             }
         ];
+        describe('simple tests', () => {
+            test.each(simpleTestsData)('deepEqual($value1, $value2) -> $expected', ({value1, value2, expected}) => {
+                const actual1 = deepEqual(value1, value2);
+                expect(actual1).toStrictEqual(expected);
+
+                const actual2 = deepEqual(value2, value1);
+                expect(actual2).toStrictEqual(expected);
+            });
+        });
+
+        describe('simple object tests', () => {
+            test.each(simpleObjectTestsData)('deepEqual($value1, $value2) -> $expected', ({value1, value2, expected}) => {
+                const actual1 = deepEqual(value1, value2);
+                expect(actual1).toStrictEqual(expected);
+
+                const actual2 = deepEqual(value2, value1);
+                expect(actual2).toStrictEqual(expected);
+            });
+        });
+
+        describe('complex object tests', () => {
+            test.each(complexObjectTestsData)('deepEqual($value1, $value2) -> $expected', ({value1, value2, expected}) => {
+                const actual1 = deepEqual(value1, value2);
+                expect(actual1).toStrictEqual(expected);
+
+                const actual2 = deepEqual(value2, value1);
+                expect(actual2).toStrictEqual(expected);
+            });
+        });
 
-        let index = 0;
-        for (const {value1, value2, expected} of data) {
-            test(`${index}`, () => {
+        describe('recursive tests', () => {
+            test.each(recursiveTestsData)('deepEqual($value1, $value2) -> $expected', ({value1, value2, expected}) => {
                 const actual1 = deepEqual(value1, value2);
                 expect(actual1).toStrictEqual(expected);
 
                 const actual2 = deepEqual(value2, value1);
                 expect(actual2).toStrictEqual(expected);
             });
-            ++index;
-        }
+        });
     });
 }
 
diff --git a/test/css-json.test.js b/test/css-json.test.js
index e4155ca3..588651d2 100644
--- a/test/css-json.test.js
+++ b/test/css-json.test.js
@@ -17,17 +17,17 @@
  */
 
 import fs from 'fs';
-import {expect, test} from 'vitest';
+import {describe, expect, test} from 'vitest';
 import {formatRulesJson, generateRules, getTargets} from '../dev/generate-css-json';
 
 /** */
 function main() {
-    test('css-json', () => {
-        for (const {cssFilePath, overridesCssFilePath, outputPath} of getTargets()) {
+    describe('css-json', () => {
+        test.each(getTargets())('css-json-test-%#', ({cssFilePath, overridesCssFilePath, outputPath}) => {
             const actual = fs.readFileSync(outputPath, {encoding: 'utf8'});
             const expected = formatRulesJson(generateRules(cssFilePath, overridesCssFilePath));
             expect(actual).toStrictEqual(expected);
-        }
+        });
     });
 }
 
diff --git a/test/hotkey-util.test.js b/test/hotkey-util.test.js
index 5b8c4e73..d89d571d 100644
--- a/test/hotkey-util.test.js
+++ b/test/hotkey-util.test.js
@@ -18,12 +18,12 @@
 
 /* eslint-disable no-multi-spaces */
 
-import {expect, test} from 'vitest';
+import {describe, expect, test} from 'vitest';
 import {HotkeyUtil} from '../ext/js/input/hotkey-util.js';
 
 /** */
 function testCommandConversions() {
-    test('CommandConversions', () => {
+    describe('CommandConversions', () => {
         /** @type {{os: import('environment').OperatingSystem, command: string, expectedCommand: string, expectedInput: {key: string, modifiers: import('input').Modifier[]}}[]} */
         const data = [
             {os: 'win', command: 'Alt+F', expectedCommand: 'Alt+F', expectedInput: {key: 'KeyF', modifiers: ['alt']}},
@@ -44,18 +44,20 @@ function testCommandConversions() {
 
         const hotkeyUtil = new HotkeyUtil();
         for (const {command, os, expectedInput, expectedCommand} of data) {
-            hotkeyUtil.os = os;
-            const input = structuredClone(hotkeyUtil.convertCommandToInput(command));
-            expect(input).toStrictEqual(expectedInput);
-            const command2 = hotkeyUtil.convertInputToCommand(input.key, input.modifiers);
-            expect(command2).toStrictEqual(expectedCommand);
+            test(`${command} on ${os} -> ${JSON.stringify(expectedInput)}`, () => {
+                hotkeyUtil.os = os;
+                const input = structuredClone(hotkeyUtil.convertCommandToInput(command));
+                expect(input).toStrictEqual(expectedInput);
+                const command2 = hotkeyUtil.convertInputToCommand(input.key, input.modifiers);
+                expect(command2).toStrictEqual(expectedCommand);
+            });
         }
     });
 }
 
 /** */
 function testDisplayNames() {
-    test('DisplayNames', () => {
+    describe('DisplayNames', () => {
         /** @type {{os: import('environment').OperatingSystem, key: ?string, modifiers: import('input').Modifier[], expected: string}[]} */
         const data = [
             {os: 'win', key: null,   modifiers: [], expected: ''},
@@ -136,17 +138,18 @@ function testDisplayNames() {
         ];
 
         const hotkeyUtil = new HotkeyUtil();
-        for (const {os, key, modifiers, expected} of data) {
+
+        test.each(data)('$key with $modifiers on $os -> display value $expected', ({os, key, modifiers, expected}) => {
             hotkeyUtil.os = os;
             const displayName = hotkeyUtil.getInputDisplayValue(key, modifiers);
             expect(displayName).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testSortModifiers() {
-    test('SortModifiers', () => {
+    describe('SortModifiers', () => {
         /** @type {{modifiers: import('input').Modifier[], expected: import('input').Modifier[]}[]} */
         const data = [
             {modifiers: [], expected: []},
@@ -155,9 +158,11 @@ function testSortModifiers() {
 
         const hotkeyUtil = new HotkeyUtil();
         for (const {modifiers, expected} of data) {
-            const modifiers2 = hotkeyUtil.sortModifiers(modifiers);
-            expect(modifiers2).toStrictEqual(modifiers);
-            expect(modifiers2).toStrictEqual(expected);
+            test(`[${modifiers}] -> [${expected}]`, () => {
+                const modifiers2 = hotkeyUtil.sortModifiers(modifiers);
+                expect(modifiers2).toStrictEqual(modifiers);
+                expect(modifiers2).toStrictEqual(expected);
+            });
         }
     });
 }
diff --git a/test/japanese-util.test.js b/test/japanese-util.test.js
index 6e594a2f..177af4d5 100644
--- a/test/japanese-util.test.js
+++ b/test/japanese-util.test.js
@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import {expect, test} from 'vitest';
+import {describe, expect, test} from 'vitest';
 import {TextSourceMap} from '../ext/js/general/text-source-map.js';
 import {JapaneseUtil} from '../ext/js/language/sandbox/japanese-util.js';
 import * as wanakana from '../ext/lib/wanakana.js';
@@ -25,7 +25,7 @@ const jp = new JapaneseUtil(wanakana);
 
 /** */
 function testIsCodePointKanji() {
-    test('isCodePointKanji', () => {
+    describe('isCodePointKanji', () => {
         /** @type {[characters: string, expected: boolean][]} */
         const data = [
             ['力方', true],
@@ -34,19 +34,19 @@ function testIsCodePointKanji() {
             ['逸逸', true]
         ];
 
-        for (const [characters, expected] of data) {
+        test.each(data)('%s -> %o', (characters, expected) => {
             for (const character of characters) {
                 const codePoint = /** @type {number} */ (character.codePointAt(0));
                 const actual = jp.isCodePointKanji(codePoint);
                 expect(actual).toStrictEqual(expected); // `isCodePointKanji failed for ${character} (\\u{${codePoint.toString(16)}})`
             }
-        }
+        });
     });
 }
 
 /** */
 function testIsCodePointKana() {
-    test('isCodePointKana', () => {
+    describe('isCodePointKana', () => {
         /** @type {[characters: string, expected: boolean][]} */
         const data = [
             ['かたカタ', true],
@@ -54,19 +54,19 @@ function testIsCodePointKana() {
             ['\u53f1\u{20b9f}', false]
         ];
 
-        for (const [characters, expected] of data) {
+        test.each(data)('%s -> %o', (characters, expected) => {
             for (const character of characters) {
                 const codePoint = /** @type {number} */ (character.codePointAt(0));
                 const actual = jp.isCodePointKana(codePoint);
                 expect(actual).toStrictEqual(expected); // `isCodePointKana failed for ${character} (\\u{${codePoint.toString(16)}})`
             }
-        }
+        });
     });
 }
 
 /** */
 function testIsCodePointJapanese() {
-    test('isCodePointJapanese', () => {
+    describe('isCodePointJapanese', () => {
         /** @type {[characters: string, expected: boolean][]} */
         const data = [
             ['かたカタ力方々、。？', true],
@@ -75,19 +75,19 @@ function testIsCodePointJapanese() {
             ['逸逸', true]
         ];
 
-        for (const [characters, expected] of data) {
+        test.each(data)('%s -> %o', (characters, expected) => {
             for (const character of characters) {
                 const codePoint = /** @type {number} */ (character.codePointAt(0));
                 const actual = jp.isCodePointJapanese(codePoint);
                 expect(actual).toStrictEqual(expected); // `isCodePointJapanese failed for ${character} (\\u{${codePoint.toString(16)}})`
             }
-        }
+        });
     });
 }
 
 /** */
 function testIsStringEntirelyKana() {
-    test('isStringEntirelyKana', () => {
+    describe('isStringEntirelyKana', () => {
         /** @type {[string: string, expected: boolean][]} */
         const data = [
             ['かたかな', true],
@@ -103,15 +103,15 @@ function testIsStringEntirelyKana() {
             ['kata,.?かた', false]
         ];
 
-        for (const [string, expected] of data) {
+        test.each(data)('%s -> %o', (string, expected) => {
             expect(jp.isStringEntirelyKana(string)).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testIsStringPartiallyJapanese() {
-    test('isStringPartiallyJapanese', () => {
+    describe('isStringPartiallyJapanese', () => {
         /** @type {[string: string, expected: boolean][]} */
         const data = [
             ['かたかな', true],
@@ -128,15 +128,15 @@ function testIsStringPartiallyJapanese() {
             ['逸逸', true]
         ];
 
-        for (const [string, expected] of data) {
+        test.each(data)('%s -> %o', (string, expected) => {
             expect(jp.isStringPartiallyJapanese(string)).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testConvertKatakanaToHiragana() {
-    test('convertKatakanaToHiragana', () => {
+    describe('convertKatakanaToHiragana', () => {
         /** @type {[string: string, expected: string, keepProlongedSoundMarks?: boolean][]} */
         const data = [
             ['かたかな', 'かたかな'],
@@ -153,14 +153,16 @@ function testConvertKatakanaToHiragana() {
         ];
 
         for (const [string, expected, keepProlongedSoundMarks = false] of data) {
-            expect(jp.convertKatakanaToHiragana(string, keepProlongedSoundMarks)).toStrictEqual(expected);
+            test(`${string}${keepProlongedSoundMarks ? ' keeping prolonged sound marks' : ''} -> ${expected}`, () => {
+                expect(jp.convertKatakanaToHiragana(string, keepProlongedSoundMarks)).toStrictEqual(expected);
+            });
         }
     });
 }
 
 /** */
 function testConvertHiraganaToKatakana() {
-    test('ConvertHiraganaToKatakana', () => {
+    describe('ConvertHiraganaToKatakana', () => {
         /** @type {[string: string, expected: string][]} */
         const data = [
             ['かたかな', 'カタカナ'],
@@ -174,15 +176,15 @@ function testConvertHiraganaToKatakana() {
             ['hiragana', 'hiragana']
         ];
 
-        for (const [string, expected] of data) {
+        test.each(data)('%s -> %o', (string, expected) => {
             expect(jp.convertHiraganaToKatakana(string)).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testConvertToRomaji() {
-    test('ConvertToRomaji', () => {
+    describe('ConvertToRomaji', () => {
         /** @type {[string: string, expected: string][]} */
         const data = [
             ['かたかな', 'katakana'],
@@ -196,15 +198,15 @@ function testConvertToRomaji() {
             ['hiragana', 'hiragana']
         ];
 
-        for (const [string, expected] of data) {
+        test.each(data)('%s -> %o', (string, expected) => {
             expect(jp.convertToRomaji(string)).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testConvertNumericToFullWidth() {
-    test('ConvertNumericToFullWidth', () => {
+    describe('ConvertNumericToFullWidth', () => {
         /** @type {[string: string, expected: string][]} */
         const data = [
             ['0123456789', '０１２３４５６７８９'],
@@ -213,15 +215,15 @@ function testConvertNumericToFullWidth() {
             ['ひらがな', 'ひらがな']
         ];
 
-        for (const [string, expected] of data) {
+        test.each(data)('%s -> %o', (string, expected) => {
             expect(jp.convertNumericToFullWidth(string)).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testConvertHalfWidthKanaToFullWidth() {
-    test('ConvertHalfWidthKanaToFullWidth', () => {
+    describe('ConvertHalfWidthKanaToFullWidth', () => {
         /** @type {[string: string, expected: string, expectedSourceMapping?: number[]][]} */
         const data = [
             ['0123456789', '0123456789'],
@@ -235,21 +237,23 @@ function testConvertHalfWidthKanaToFullWidth() {
         ];
 
         for (const [string, expected, expectedSourceMapping] of data) {
-            const sourceMap = new TextSourceMap(string);
-            const actual1 = jp.convertHalfWidthKanaToFullWidth(string, null);
-            const actual2 = jp.convertHalfWidthKanaToFullWidth(string, sourceMap);
-            expect(actual1).toStrictEqual(expected);
-            expect(actual2).toStrictEqual(expected);
-            if (typeof expectedSourceMapping !== 'undefined') {
-                expect(sourceMap.equals(new TextSourceMap(string, expectedSourceMapping))).toBe(true);
-            }
+            test(`${string} -> ${expected}${typeof expectedSourceMapping !== 'undefined' ? ', ' + JSON.stringify(expectedSourceMapping) : ''}`, () => {
+                const sourceMap = new TextSourceMap(string);
+                const actual1 = jp.convertHalfWidthKanaToFullWidth(string, null);
+                const actual2 = jp.convertHalfWidthKanaToFullWidth(string, sourceMap);
+                expect(actual1).toStrictEqual(expected);
+                expect(actual2).toStrictEqual(expected);
+                if (typeof expectedSourceMapping !== 'undefined') {
+                    expect(sourceMap.equals(new TextSourceMap(string, expectedSourceMapping))).toBe(true);
+                }
+            });
         }
     });
 }
 
 /** */
 function testConvertAlphabeticToKana() {
-    test('ConvertAlphabeticToKana', () => {
+    describe('ConvertAlphabeticToKana', () => {
         /** @type {[string: string, expected: string, expectedSourceMapping?: number[]][]} */
         const data = [
             ['0123456789', '0123456789'],
@@ -262,21 +266,23 @@ function testConvertAlphabeticToKana() {
         ];
 
         for (const [string, expected, expectedSourceMapping] of data) {
-            const sourceMap = new TextSourceMap(string);
-            const actual1 = jp.convertAlphabeticToKana(string, null);
-            const actual2 = jp.convertAlphabeticToKana(string, sourceMap);
-            expect(actual1).toStrictEqual(expected);
-            expect(actual2).toStrictEqual(expected);
-            if (typeof expectedSourceMapping !== 'undefined') {
-                expect(sourceMap.equals(new TextSourceMap(string, expectedSourceMapping))).toBe(true);
-            }
+            test(`${string} -> ${string}${typeof expectedSourceMapping !== 'undefined' ? ', ' + JSON.stringify(expectedSourceMapping) : ''}`, () => {
+                const sourceMap = new TextSourceMap(string);
+                const actual1 = jp.convertAlphabeticToKana(string, null);
+                const actual2 = jp.convertAlphabeticToKana(string, sourceMap);
+                expect(actual1).toStrictEqual(expected);
+                expect(actual2).toStrictEqual(expected);
+                if (typeof expectedSourceMapping !== 'undefined') {
+                    expect(sourceMap.equals(new TextSourceMap(string, expectedSourceMapping))).toBe(true);
+                }
+            });
         }
     });
 }
 
 /** */
 function testDistributeFurigana() {
-    test('DistributeFurigana', () => {
+    describe('DistributeFurigana', () => {
         /** @type {[input: [term: string, reading: string], expected: {text: string, reading: string}[]][]} */
         const data = [
             [
@@ -736,16 +742,17 @@ function testDistributeFurigana() {
             ]
         ];
 
-        for (const [[term, reading], expected] of data) {
+        test.each(data)('%o -> %o', (input, expected) => {
+            const [term, reading] = input;
             const actual = jp.distributeFurigana(term, reading);
             expect(actual).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testDistributeFuriganaInflected() {
-    test('DistributeFuriganaInflected', () => {
+    describe('DistributeFuriganaInflected', () => {
         /** @type {[input: [term: string, reading: string, source: string], expected: {text: string, reading: string}[]][]} */
         const data = [
             [
@@ -789,16 +796,17 @@ function testDistributeFuriganaInflected() {
             ]
         ];
 
-        for (const [[term, reading, source], expected] of data) {
+        test.each(data)('%o -> %o', (input, expected) => {
+            const [term, reading, source] = input;
             const actual = jp.distributeFuriganaInflected(term, reading, source);
             expect(actual).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testCollapseEmphaticSequences() {
-    test('CollapseEmphaticSequences', () => {
+    describe('CollapseEmphaticSequences', () => {
         /** @type {[input: [text: string, fullCollapse: boolean], output: [expected: string, expectedSourceMapping: number[]]][]} */
         const data = [
             [['かこい', false], ['かこい', [1, 1, 1]]],
@@ -840,7 +848,10 @@ function testCollapseEmphaticSequences() {
             [['っっっ', true], ['', [3]]]
         ];
 
-        for (const [[text, fullCollapse], [expected, expectedSourceMapping]] of data) {
+        test.each(data)('%o -> %o', (input, output) => {
+            const [text, fullCollapse] = input;
+            const [expected, expectedSourceMapping] = output;
+
             const sourceMap = new TextSourceMap(text);
             const actual1 = jp.collapseEmphaticSequences(text, fullCollapse, null);
             const actual2 = jp.collapseEmphaticSequences(text, fullCollapse, sourceMap);
@@ -849,13 +860,13 @@ function testCollapseEmphaticSequences() {
             if (typeof expectedSourceMapping !== 'undefined') {
                 expect(sourceMap.equals(new TextSourceMap(text, expectedSourceMapping))).toBe(true);
             }
-        }
+        });
     });
 }
 
 /** */
 function testIsMoraPitchHigh() {
-    test('IsMoraPitchHigh', () => {
+    describe('IsMoraPitchHigh', () => {
         /** @type {[input: [moraIndex: number, pitchAccentDownstepPosition: number], expected: boolean][]} */
         const data = [
             [[0, 0], false],
@@ -884,16 +895,17 @@ function testIsMoraPitchHigh() {
             [[3, 4], true]
         ];
 
-        for (const [[moraIndex, pitchAccentDownstepPosition], expected] of data) {
+        test.each(data)('%o -> %o', (input, expected) => {
+            const [moraIndex, pitchAccentDownstepPosition] = input;
             const actual = jp.isMoraPitchHigh(moraIndex, pitchAccentDownstepPosition);
             expect(actual).toStrictEqual(expected);
-        }
+        });
     });
 }
 
 /** */
 function testGetKanaMorae() {
-    test('GetKanaMorae', () => {
+    describe('GetKanaMorae', () => {
         /** @type {[text: string, expected: string[]][]} */
         const data = [
             ['かこ', ['か', 'こ']],
@@ -907,10 +919,10 @@ function testGetKanaMorae() {
             ['ディスコ', ['ディ', 'ス', 'コ']]
         ];
 
-        for (const [text, expected] of data) {
+        test.each(data)('%s -> %o', (text, expected) => {
             const actual = jp.getKanaMorae(text);
             expect(actual).toStrictEqual(expected);
-        }
+        });
     });
 }
 
diff --git a/test/json-schema.test.js b/test/json-schema.test.js
index 0c1a483b..4773e898 100644
--- a/test/json-schema.test.js
+++ b/test/json-schema.test.js
@@ -18,7 +18,7 @@
 
 /* eslint-disable no-multi-spaces */
 
-import {expect, test} from 'vitest';
+import {describe, expect, test} from 'vitest';
 import {parseJson} from '../dev/json.js';
 import {JsonSchema} from '../ext/js/data/json-schema.js';
 
@@ -61,7 +61,7 @@ function clone(value) {
 
 /** */
 function testValidate1() {
-    test('Validate1', () => {
+    describe('Validate1', () => {
         /** @type {import('ext/json-schema').Schema} */
         const schema = {
             allOf: [
@@ -112,17 +112,19 @@ function testValidate1() {
             );
         };
 
-        for (let i = -111; i <= 111; i++) {
-            const actual = schemaValidate(schema, i);
-            const expected = jsValidate(i);
-            expect(actual).toStrictEqual(expected);
-        }
+        test('works as expected', () => {
+            for (let i = -111; i <= 111; i++) {
+                const actual = schemaValidate(schema, i);
+                const expected = jsValidate(i);
+                expect(actual).toStrictEqual(expected);
+            }
+        });
     });
 }
 
 /** */
 function testValidate2() {
-    test('Validate2', () => {
+    describe('Validate2', () => {
         /** @type {{schema: import('ext/json-schema').Schema, inputs: {expected: boolean, value: unknown}[]}[]} */
         const data = [
             // String tests
@@ -517,19 +519,19 @@ function testValidate2() {
             }
         ];
 
-        for (const {schema, inputs} of data) {
-            for (const {expected, value} of inputs) {
+        describe.each(data)('Schema %#', ({schema, inputs}) => {
+            test.each(inputs)(`schemaValidate(${schema}, $value) -> $expected`, ({expected, value}) => {
                 const actual = schemaValidate(schema, value);
                 expect(actual).toStrictEqual(expected);
-            }
-        }
+            });
+        });
     });
 }
 
 
 /** */
 function testGetValidValueOrDefault1() {
-    test('GetValidValueOrDefault1', () => {
+    describe('GetValidValueOrDefault1', () => {
         /** @type {{schema: import('ext/json-schema').Schema, inputs: [value: unknown, expected: unknown][]}[]} */
         const data = [
             // Test value defaulting on objects with additionalProperties=false
@@ -875,19 +877,19 @@ function testGetValidValueOrDefault1() {
             }
         ];
 
-        for (const {schema, inputs} of data) {
-            for (const [value, expected] of inputs) {
+        describe.each(data)('Schema %#', ({schema, inputs}) => {
+            test.each(inputs)(`getValidValueOrDefault(${schema}, %o) -> %o`, (value, expected) => {
                 const actual = getValidValueOrDefault(schema, value);
                 expect(actual).toStrictEqual(expected);
-            }
-        }
+            });
+        });
     });
 }
 
 
 /** */
 function testProxy1() {
-    test('Proxy1', () => {
+    describe('Proxy1', () => {
         /** @type {{schema: import('ext/json-schema').Schema, tests: {error: boolean, value?: import('ext/json-schema').Value, action: (value: import('core').SafeAny) => void}[]}[]} */
         const data = [
             // Object tests
@@ -1018,6 +1020,20 @@ function testProxy1() {
             }
         ];
 
+        describe.each(data)('Schema %#', ({schema, tests}) => {
+            test.each(tests)('proxy %#', ({error, value, action}) => {
+                if (typeof value === 'undefined') { value = getValidValueOrDefault(schema, void 0); }
+                value = clone(value);
+                expect(schemaValidate(schema, value)).toBe(true);
+                const valueProxy = createProxy(schema, value);
+                if (error) {
+                    expect(() => action(valueProxy)).toThrow();
+                } else {
+                    expect(() => action(valueProxy)).not.toThrow();
+                }
+            });
+        });
+
         for (const {schema, tests} of data) {
             for (let {error, value, action} of tests) {
                 if (typeof value === 'undefined') { value = getValidValueOrDefault(schema, void 0); }
diff --git a/types/test/core.d.ts b/types/test/core.d.ts
new file mode 100644
index 00000000..c01737e6
--- /dev/null
+++ b/types/test/core.d.ts
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023  Yomitan Authors
+ *
+ * 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/>.
+ */
+
+type Operation = 'set.defaultValue' | 'setOverride' | 'clearOverride';
+
+type DynamicPropertyTestOperation = {
+    operation: Operation | null;
+    expectedDefaultValue: number;
+    expectedValue: number;
+    expectedOverrideCount: number;
+    expectedEventOccurred: boolean;
+    args: [value: number, priority?: number];
+};
+
+export type DynamicPropertyTestData = {
+    initialValue: number;
+    operations: DynamicPropertyTestOperation[];
+}[];
+
+export type DeepEqualTestData = {
+    value1: unknown;
+    value2: unknown;
+    expected: boolean;
+}[];