@keymanapp/common-types 17.0.85-alpha

package/test/helpers/reader-callback-test.ts

@@ -0,0 +1,199 @@
+import 'mocha';
+import {assert} from 'chai';
+import {loadLdmlKeyboardSchema, loadFile, makePathToFixture, loadLdmlKeyboardTestDataSchema} from '../helpers/index.js';
+import LDMLKeyboardXMLSourceFileReader from '../../src/ldml-keyboard/ldml-keyboard-xml-reader.js';
+import { CompilerCallbacks, CompilerEvent } from '../../src/util/compiler-interfaces.js';
+import { LDMLKeyboardXMLSourceFile } from '../../src/ldml-keyboard/ldml-keyboard-xml.js';
+import { LDMLKeyboardTestDataXMLSourceFile } from '../ldml-keyboard/ldml-keyboard-testdata-xml.js';
+
+// This is related to developer/src/kmc-keyboard/test/helpers/index.ts but has a slightly different API surface
+// as this runs at a lower level than the compiler.
+
+/**
+ * A CompilerCallbacks implementation for testing
+ */
+class TestCompilerCallbacks implements CompilerCallbacks {
+  loadKpjJsonSchema(): Buffer {
+    throw new Error('loadKpjJsonSchema not implemented.'); // not needed for this test
+  }
+  loadLdmlKeyboardTestSchema(): Buffer {
+    return loadLdmlKeyboardTestDataSchema();
+  }
+  loadLdmlKeyboardSchema(): Buffer {
+    return loadLdmlKeyboardSchema();
+  }
+  loadKvksJsonSchema(): Buffer {
+    throw new Error('loadKvksJsonSchema not implemented.');
+  }
+  clear() {
+    this.messages = [];
+  }
+  messages: CompilerEvent[] = [];
+  loadFile(baseFilename: string, filename: string | URL): Buffer {
+    try {
+      return loadFile(baseFilename, filename);
+    } catch(e) {
+      if (e.code === 'ENOENT') {
+        return null;
+      } else {
+        throw e;
+      }
+    }
+  }
+  reportMessage(event: CompilerEvent): void {
+    // console.log(event.message);
+    this.messages.push(event);
+  }
+}
+
+export interface CompilationCase {
+  /**
+   * If true, loading (validation) should fail
+   */
+  loadfail?: boolean;
+  /**
+   * path to xml, such as 'sections/layr/invalid-case.xml'
+   */
+  subpath: string;
+  /**
+   * expected error messages. If falsy, expected to succeed. All must be present to pass.
+   */
+  errors?: CompilerEvent[];
+  /**
+   * expected warning messages. All must be present to pass.
+   */
+  warnings?: CompilerEvent[];
+  /**
+   * optional callback with the section
+   */
+  callback?: (data: Buffer, source: LDMLKeyboardXMLSourceFile, subpath: string, callbacks: TestCompilerCallbacks ) => void;
+  /**
+   * if present, expect compiler to throw (use .* to match all)
+   */
+  throws?: RegExp;
+}
+
+
+export interface TestDataCase {
+  /**
+   * If true, loading (validation) should fail
+   */
+  loadfail?: boolean;
+  /**
+   * path to xml, such as 'sections/layr/invalid-case.xml'
+   */
+  subpath: string;
+  /**
+   * expected error messages. If falsy, expected to succeed. All must be present to pass.
+   */
+  errors?: CompilerEvent[];
+  /**
+   * expected warning messages. All must be present to pass.
+   */
+  warnings?: CompilerEvent[];
+  /**
+   * optional callback with the section
+   */
+  callback?: (data: Buffer, source: LDMLKeyboardTestDataXMLSourceFile, subpath: string, callbacks: TestCompilerCallbacks ) => void;
+  /**
+   * if present, expect compiler to throw (use .* to match all)
+   */
+  throws?: RegExp;
+}
+
+/**
+ * Run a bunch of cases
+ * @param cases cases to run
+ * @param compiler argument to loadSectionFixture()
+ * @param callbacks argument to loadSectionFixture()
+ */
+export function testReaderCases(cases : CompilationCase[]) {
+  // we need our own callbacks rather than using the global so messages don't get mixed
+  const callbacks = new TestCompilerCallbacks();
+  const reader = new LDMLKeyboardXMLSourceFileReader(callbacks);
+  for (let testcase of cases) {
+    const expectFailure = testcase.throws || !!(testcase.errors); // if true, we expect this to fail
+    const testHeading = expectFailure ? `should fail to load: ${testcase.subpath}`:
+                                        `should load: ${testcase.subpath}`;
+    it(testHeading, function () {
+      callbacks.clear();
+
+      const data = loadFile(testcase.subpath, makePathToFixture(testcase.subpath));
+      assert.ok(data, `reading ${testcase.subpath}`);
+      const source = reader.load(data);
+      if (!testcase.loadfail) {
+        assert.ok(source, `loading ${testcase.subpath}`);
+      } else {
+        assert.notOk(source, `loading ${testcase.subpath} (expected failure)`);
+      }
+      // special case for an expected exception
+      if (testcase.throws) {
+        assert.throws(() => reader.validate(source, loadLdmlKeyboardSchema()), testcase.throws);
+      } else {
+        assert.doesNotThrow(() => reader.validate(source, loadLdmlKeyboardSchema()), `validating ${testcase.subpath}`);
+        // if we expected errors or warnings, show them
+        if (testcase.errors) {
+          assert.includeDeepMembers(callbacks.messages, testcase.errors, 'expected errors to be included');
+        }
+        if (testcase.warnings) {
+          assert.includeDeepMembers(callbacks.messages, testcase.warnings, 'expected warnings to be included');
+        } else if (!expectFailure) {
+          // no warnings, so expect zero messages
+          assert.strictEqual(callbacks.messages.length, 0, 'expected zero messages');
+        }
+
+        // run the user-supplied callback if any
+        if (testcase.callback) {
+          testcase.callback(data, source, testcase.subpath, callbacks);
+        }
+      }
+    });
+  }
+}
+
+
+/**
+ * Run a bunch of cases
+ * @param cases cases to run
+ * @param compiler argument to loadSectionFixture()
+ * @param callbacks argument to loadSectionFixture()
+ */
+export function testTestdataReaderCases(cases : TestDataCase[]) {
+  // we need our own callbacks rather than using the global so messages don't get mixed
+  const callbacks = new TestCompilerCallbacks();
+  const reader = new LDMLKeyboardXMLSourceFileReader(callbacks);
+  for (let testcase of cases) {
+    const expectFailure = testcase.throws || !!(testcase.errors); // if true, we expect this to fail
+    const testHeading = expectFailure ? `should fail to load: ${testcase.subpath}`:
+                                        `should load: ${testcase.subpath}`;
+    it(testHeading, function () {
+      callbacks.clear();
+
+      const data = loadFile(testcase.subpath, makePathToFixture(testcase.subpath));
+      assert.ok(data, `reading ${testcase.subpath}`);
+      const source = reader.loadTestData(data);
+      if (!testcase.loadfail) {
+        assert.ok(source, `loading ${testcase.subpath}`);
+      } else {
+        assert.notOk(source, `loading ${testcase.subpath} (expected failure)`);
+      }
+      // special case for an expected exception
+      // TODO-LDML: no validation for now.
+      // if we expected errors or warnings, show them
+      if (testcase.errors) {
+        assert.includeDeepMembers(callbacks.messages, testcase.errors, 'expected errors to be included');
+      }
+      if (testcase.warnings) {
+        assert.includeDeepMembers(callbacks.messages, testcase.warnings, 'expected warnings to be included');
+      } else if (!expectFailure) {
+        // no warnings, so expect zero messages
+        assert.strictEqual(callbacks.messages.length, 0, 'expected zero messages but got ' +callbacks.messages.map(e => e.message).join(' ') );
+      }
+
+      // run the user-supplied callback if any
+      if (testcase.callback) {
+        testcase.callback(data, source, testcase.subpath, callbacks);
+      }
+    });
+  }
+}

package/test/keyman-touch-layout/test-keyman-touch-layout-file-reader.ts

@@ -0,0 +1,71 @@
+import * as fs from 'fs';
+import 'mocha';
+import { assert } from 'chai';
+import { loadKeymanTouchLayoutCleanJsonSchema, makePathToFixture } from '../helpers/index.js';
+import { TouchLayoutFileReader } from "../../src/keyman-touch-layout/keyman-touch-layout-file-reader.js";
+
+describe('TouchLayoutFileReader', function () {
+  it('should read a valid file', function() {
+    const path = makePathToFixture('keyman-touch-layout', 'khmer_angkor.keyman-touch-layout');
+    const schema = loadKeymanTouchLayoutCleanJsonSchema();
+    const input = fs.readFileSync(path);
+    const reader = new TouchLayoutFileReader();
+    const layout = reader.read(input);
+    reader.validate(layout, schema);
+
+    // We don't really need to validate the JSON parser. We'll do a handful of
+    // tests for object integrity and a couple of object members inside the file
+    // just as a sanity check
+    assert.hasAllKeys(layout, ['tablet', 'phone']);
+    assert.hasAllKeys(layout.tablet, ['layer', 'displayUnderlying', 'font', 'fontsize']);
+    assert.isFalse(layout.tablet.displayUnderlying);
+    assert.strictEqual(layout.tablet.font, 'Khmer Busra Kbd');
+    assert.strictEqual(layout.tablet.fontsize, '0.8em');
+    assert.isArray(layout.tablet.layer);
+    assert.strictEqual(layout.tablet.layer.length, 3);
+    assert.strictEqual(layout.tablet.layer[0].id, 'default');
+    assert.isArray(layout.tablet.layer[0].row);
+    assert.isArray(layout.tablet.layer[0].row);
+    assert.strictEqual(layout.tablet.layer[0].row.length, 5);
+    assert.strictEqual(layout.tablet.layer[0].row[0].id, 1);
+    assert.isArray(layout.tablet.layer[0].row[0].key);
+    assert.strictEqual(layout.tablet.layer[0].row[0].key.length, 13);
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].id, "K_1");
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].text, "១");
+  });
+
+  it('should fixup numeric types in a valid legacy file', function() {
+    const path = makePathToFixture('keyman-touch-layout', 'legacy.keyman-touch-layout');
+    const schema = loadKeymanTouchLayoutCleanJsonSchema();
+    const input = fs.readFileSync(path);
+    const reader = new TouchLayoutFileReader();
+    const layout = reader.read(input);
+    reader.validate(layout, schema);
+
+    // row.id can be a string in legacy files
+    assert.strictEqual(layout.tablet.layer[0].row[0].id, 1);
+
+    // key pad, width and sp can be a string in legacy files
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].pad, 25);
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].width, 100);
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].sp, 1);
+
+    // sk pad, width and sp can be a string in legacy files
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].sk[0].pad, 10);
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].sk[0].width, 25);
+    assert.strictEqual(layout.tablet.layer[0].row[0].key[0].sk[0].sp, 8);
+  });
+
+  it('should fixup remove empty arrays in a valid legacy file', function() {
+    const path = makePathToFixture('keyman-touch-layout', 'legacy.keyman-touch-layout');
+    const schema = loadKeymanTouchLayoutCleanJsonSchema();
+    const input = fs.readFileSync(path);
+    const reader = new TouchLayoutFileReader();
+    const layout = reader.read(input);
+    reader.validate(layout, schema);
+
+    // sk was defined as [] in legacy.keyman-touch-layout but we want to treat
+    // it as not present
+    assert.isUndefined(layout.tablet.layer[0].row[0].key[1].sk);
+  });
+});

package/test/keyman-touch-layout/test-keyman-touch-layout-round-trip.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import 'mocha';
+import { assert } from 'chai';
+import { makePathToFixture } from '../helpers/index.js';
+import { TouchLayoutFileReader } from "../../src/keyman-touch-layout/keyman-touch-layout-file-reader.js";
+import { TouchLayoutFileWriter } from "../../src/keyman-touch-layout/keyman-touch-layout-file-writer.js";
+
+describe('TouchLayoutFile', function () {
+  it('should round-trip from TouchLayoutFileReader to TouchLayoutFileWriter', function() {
+    const path = makePathToFixture('keyman-touch-layout', 'khmer_angkor.keyman-touch-layout');
+    const input = fs.readFileSync(path);
+    const reader = new TouchLayoutFileReader();
+    const layout = reader.read(input);
+    const writer = new TouchLayoutFileWriter();
+
+    // We don't want to assert equality on formatting differences, or on the
+    // fixups that we do on input files (empty arrays, stringified numbers), so
+    // we'll re-read the output and compare it
+    let output = writer.write(layout);
+    let newLayout = reader.read(output);
+    assert.deepEqual(layout, newLayout);
+
+    // And do the same without formatted output
+    output = writer.write(layout);
+    newLayout = reader.read(output);
+    assert.deepEqual(layout, newLayout);
+
+    // And do the same without any options
+    let output2 = writer.write(layout);
+    assert.deepEqual(output, output2);
+
+    newLayout = reader.read(output2);
+    assert.deepEqual(layout, newLayout);
+  });
+});

package/test/kpj/test-kpj-file-reader.ts

@@ -0,0 +1,123 @@
+import * as fs from 'fs';
+import 'mocha';
+import {assert} from 'chai';
+import { loadKpjJsonSchema, makePathToFixture } from '../helpers/index.js';
+import { KPJFileReader } from "../../src/kpj/kpj-file-reader.js";
+import { KeymanDeveloperProjectFile10, KeymanDeveloperProjectType } from '../../src/kpj/keyman-developer-project.js';
+
+describe('kpj-file-reader', function () {
+  it('kpj-file-reader should read a valid file', function() {
+    const kpjPath = 'khmer_angkor.kpj';
+    const path = makePathToFixture('kpj', kpjPath);
+    const input = fs.readFileSync(path);
+    const reader = new KPJFileReader();
+    const kpj = reader.read(input);
+    console.dir(kpj);
+    assert.doesNotThrow(() => {
+      reader.validate(kpj, loadKpjJsonSchema());
+    });
+    assert.equal(kpj.KeymanDeveloperProject.Options.BuildPath, '$PROJECTPATH\\build');
+    assert.equal(kpj.KeymanDeveloperProject.Options.CheckFilenameConventions, 'False');
+    assert.equal(kpj.KeymanDeveloperProject.Options.CompilerWarningsAsErrors, 'True');
+    assert.equal(kpj.KeymanDeveloperProject.Options.ProjectType, 'keyboard');
+    assert.equal(kpj.KeymanDeveloperProject.Options.WarnDeprecatedCode, 'True');
+    assert.isUndefined(kpj.KeymanDeveloperProject.Options.Version);
+
+    assert.lengthOf(kpj.KeymanDeveloperProject.Files.File, 21);
+
+    // Test a representative set of files - kmn, kps, 2 child files
+
+    let kf = kpj.KeymanDeveloperProject.Files.File[0];
+    assert.equal(kf.ID, 'id_f347675c33d2e6b1c705c787fad4941a');
+    assert.equal(kf.Filename, 'khmer_angkor.kmn');
+    assert.equal(kf.Filepath, 'source\\khmer_angkor.kmn');
+    assert.equal(kf.FileVersion, '1.3');
+    assert.equal(kf.FileType, '.kmn');
+    assert.equal(kf.Details.Name, 'Khmer Angkor');
+    assert.equal(kf.Details.Copyright, '© 2015-2022 SIL International');
+    assert.equal(kf.Details.Message, 'More than just a Khmer Unicode keyboard.');
+
+    kf = kpj.KeymanDeveloperProject.Files.File[1];
+    assert.equal(kf.ID, 'id_8d4eb765f80c9f2b0f769cf4e4aaa456');
+    assert.equal(kf.Filename, 'khmer_angkor.kps');
+    assert.equal(kf.Filepath, 'source\\khmer_angkor.kps');
+    assert.isEmpty(kf.FileVersion);
+    assert.equal(kf.FileType, '.kps');
+    assert.equal(kf.Details.Name, 'Khmer Angkor');
+    assert.equal(kf.Details.Copyright, '© 2015-2022 SIL International');
+
+    kf = kpj.KeymanDeveloperProject.Files.File[2];
+    assert.equal(kf.ID, 'id_8a1efc7c4ab7cfece8aedd847679ca27');
+    assert.equal(kf.Filename, 'khmer_angkor.ico');
+    assert.equal(kf.Filepath, 'source\\khmer_angkor.ico');
+    assert.isEmpty(kf.FileVersion);
+    assert.equal(kf.FileType, '.ico');
+    assert.equal(kf.ParentFileID, 'id_f347675c33d2e6b1c705c787fad4941a');
+
+    kf = kpj.KeymanDeveloperProject.Files.File[3];
+    assert.equal(kf.ID, 'id_8dc195db32d1fd0514de0ad51fff5df0');
+    assert.equal(kf.Filename, 'khmer_angkor.js');
+    assert.equal(kf.Filepath, 'source\\..\\build\\khmer_angkor.js');
+    assert.isEmpty(kf.FileVersion);
+    assert.equal(kf.FileType, '.js');
+    assert.equal(kf.ParentFileID, 'id_8d4eb765f80c9f2b0f769cf4e4aaa456');
+
+    // Test transform of .kpj into a KeymanDeveloperProject
+
+    const project = reader.transform(kpjPath, kpj);
+
+    assert.equal(project.options.buildPath, '$PROJECTPATH/build');
+    assert.isFalse(project.options.checkFilenameConventions);
+    assert.isTrue(project.options.compilerWarningsAsErrors);
+    assert.equal(project.options.projectType, KeymanDeveloperProjectType.Keyboard);
+    assert.isTrue(project.options.warnDeprecatedCode);
+    assert.equal(project.options.version, '1.0');
+
+    assert.lengthOf(project.files, 2);
+
+    let f: KeymanDeveloperProjectFile10 = <KeymanDeveloperProjectFile10>project.files[0];
+    console.dir(f);
+    assert.equal(f.id, 'id_f347675c33d2e6b1c705c787fad4941a');
+    assert.equal(f.filename, 'khmer_angkor.kmn');
+    assert.equal(f.filePath, 'source/khmer_angkor.kmn');
+    assert.equal(f.fileVersion, '1.3');
+    assert.equal(f.fileType, '.kmn');
+    assert.equal(f.details.name, 'Khmer Angkor');
+    assert.equal(f.details.copyright, '© 2015-2022 SIL International');
+    assert.equal(f.details.message, 'More than just a Khmer Unicode keyboard.');
+    assert.isUndefined(f.details.version);
+    assert.lengthOf(f.childFiles, 1);
+
+    f = <KeymanDeveloperProjectFile10>project.files[1];
+    assert.equal(f.id, 'id_8d4eb765f80c9f2b0f769cf4e4aaa456');
+    assert.equal(f.filename, 'khmer_angkor.kps');
+    assert.equal(f.filePath, 'source/khmer_angkor.kps');
+    assert.equal(f.fileVersion, '');
+    assert.equal(f.fileType, '.kps');
+    assert.equal(f.details.name, 'Khmer Angkor');
+    assert.isUndefined(f.details.message);
+    assert.equal(f.details.copyright, '© 2015-2022 SIL International');
+    assert.isUndefined(f.details.version);
+    assert.lengthOf(f.childFiles, 18);
+
+    f = <KeymanDeveloperProjectFile10>project.files[0];
+    f = <KeymanDeveloperProjectFile10>f.childFiles[0];
+    assert.equal(f.id, 'id_8a1efc7c4ab7cfece8aedd847679ca27');
+    assert.equal(f.filename, 'khmer_angkor.ico');
+    assert.equal(f.filePath, 'source/khmer_angkor.ico');
+    assert.equal(f.fileVersion, '');
+    assert.equal(f.fileType, '.ico');
+    assert.isEmpty(f.details);
+    assert.lengthOf(f.childFiles, 0);
+
+    f = <KeymanDeveloperProjectFile10>project.files[1];
+    f = <KeymanDeveloperProjectFile10>f.childFiles[0];
+    assert.equal(f.id, 'id_8dc195db32d1fd0514de0ad51fff5df0');
+    assert.equal(f.filename, 'khmer_angkor.js');
+    assert.equal(f.filePath, 'source/../build/khmer_angkor.js');
+    assert.equal(f.fileVersion, '');
+    assert.equal(f.fileType, '.js');
+    assert.isEmpty(f.details);
+    assert.lengthOf(f.childFiles, 0);
+  });
+});

package/test/kvk/test-kvk-file.ts

@@ -0,0 +1,15 @@
+import * as fs from 'fs';
+import 'mocha';
+import { makePathToFixture } from '../helpers/index.js';
+import KvkFileReader from "../../src/kvk/kvk-file-reader.js";
+import { verify_khmer_angkor } from './test-kvk-utils.js';
+
+describe('kvk-file-reader', function () {
+  it('kvk-file-reader should read a valid file', function() {
+    const path = makePathToFixture('kvk', 'khmer_angkor.kvk');
+    const input = fs.readFileSync(path);
+    const reader = new KvkFileReader();
+    const vk = reader.read(input);
+    verify_khmer_angkor(vk);
+  });
+});

package/test/kvk/test-kvk-round-trip.ts

@@ -0,0 +1,87 @@
+import * as fs from 'fs';
+import 'mocha';
+import {assert} from 'chai';
+import Hexy from 'hexy';
+import gitDiff from 'git-diff';
+const { hexy } = Hexy;
+import { loadKvksJsonSchema, makePathToFixture } from '../helpers/index.js';
+import KvksFileReader, { KVKSParseError } from "../../src/kvk/kvks-file-reader.js";
+import KvkFileReader from "../../src/kvk/kvk-file-reader.js";
+import KvkFileWriter from "../../src/kvk/kvk-file-writer.js";
+import KvksFileWriter from "../../src/kvk/kvks-file-writer.js";
+
+/**
+ *
+ * @param actual input buffer
+ * @param expected expected buffer
+ * @returns
+ */
+function assertBufferMatch(actual: Buffer, expected: Buffer) {
+  const sourceHex = hexy(actual);
+  const expectedHex = hexy(expected);
+  const diff = gitDiff(expectedHex, sourceHex);
+
+  assert(!diff, 'Buffers did not match:\n' + diff);
+  assert.equal(actual.length, expected.length, 'Buffer lengths are not the same');
+  assert.deepEqual(actual, expected); // double check buffers: hexy can return '' on failure
+}
+
+describe('kvk-file-reader', function () {
+  it('kvk-file-reader should round-trip with kvk-file-writer', function() {
+    const path = makePathToFixture('kvk', 'khmer_angkor.kvk');
+    const input = fs.readFileSync(path);
+    const reader = new KvkFileReader();
+    const vk = reader.read(input);
+    const writer = new KvkFileWriter();
+    const output = writer.write(vk);
+    assertBufferMatch(input, Buffer.from(output));
+
+    // and check the 2nd generation also
+    const vk2 = reader.read(output);
+    assert.deepEqual(vk2, vk);
+  });
+});
+
+describe('kvks-file-reader', function () {
+  it('kvks-file-reader should compile with kvk-file-writer', function() {
+    const inputPath = makePathToFixture('kvk', 'khmer_angkor.kvks');
+    const compiledPath = makePathToFixture('kvk', 'khmer_angkor.kvk');
+    const input = fs.readFileSync(inputPath);
+    const compiled = fs.readFileSync(compiledPath);
+    const reader = new KvksFileReader();
+    const kvks = reader.read(input);
+    assert.doesNotThrow(() => {
+      reader.validate(kvks, loadKvksJsonSchema());
+    });
+    const errors: KVKSParseError[] = [];
+    const vk = reader.transform(kvks, errors);
+    assert.isEmpty(errors);
+    const writer = new KvkFileWriter();
+    const output = writer.write(vk);
+    assertBufferMatch(Buffer.from(output), compiled);
+  });
+
+  describe('kvks-file-writer', function() {
+    it('kvks-file-writer should match what kvk-file-reader reads', function() {
+      const kvkIn = makePathToFixture('kvk', 'khmer_angkor.kvk');
+      const kvkBuf = fs.readFileSync(kvkIn);
+      const kvkReader = new KvkFileReader();
+      const kvksReader = new KvksFileReader();
+      const vk = kvkReader.read(kvkBuf);
+      const kvksWriter = new KvksFileWriter();
+      const kvksOut = kvksWriter.write(vk);
+
+      // Now, re-read kvk from the kvks
+      const kvks = kvksReader.read(Buffer.from(kvksOut));
+      assert.doesNotThrow(() => {
+        kvksReader.validate(kvks, loadKvksJsonSchema());
+      });
+      const errors: KVKSParseError[] = [];
+      const vk2 = kvksReader.transform(kvks, errors);
+      assert.isEmpty(errors);
+
+      // make sure the binary is the same
+      assert.deepEqual(vk2, vk);
+    });
+  });
+});

package/test/kvk/test-kvk-utils.ts

@@ -0,0 +1,24 @@
+import 'mocha';
+import {assert} from 'chai';
+import { VisualKeyboard, VisualKeyboardHeaderFlags, VisualKeyboardKeyFlags, VisualKeyboardShiftState } from "../../src/kvk/visual-keyboard.js";
+import { USVirtualKeyCodes } from '../../src/consts/virtual-key-constants.js';
+
+export function verify_khmer_angkor(vk: VisualKeyboard) {
+  assert.equal(vk.header.flags, VisualKeyboardHeaderFlags.kvkhAltGr);
+  assert.equal(vk.header.associatedKeyboard, 'khmer_angkor');
+  assert.equal(vk.header.ansiFont.name, 'Arial');
+  assert.equal(vk.header.ansiFont.size, -12);
+  assert.equal(vk.header.ansiFont.color, 0xFF000008);
+  assert.equal(vk.header.unicodeFont.name, 'Khmer Busra Kbd');
+  assert.equal(vk.header.unicodeFont.size, 16);
+  assert.equal(vk.header.unicodeFont.color, 0xFF000008);
+  assert.equal(vk.keys.length, 186);
+  assert.equal(vk.keys[0].flags, VisualKeyboardKeyFlags.kvkkUnicode);
+  assert.equal(vk.keys[0].vkey, USVirtualKeyCodes.K_B);
+  assert.equal(vk.keys[0].shift, VisualKeyboardShiftState.KVKS_RALT);
+  assert.equal(vk.keys[0].text, 'ឞ');
+  assert.equal(vk.keys[185].flags, VisualKeyboardKeyFlags.kvkkUnicode);
+  assert.equal(vk.keys[185].vkey, USVirtualKeyCodes.K_COMMA);
+  assert.equal(vk.keys[185].shift, VisualKeyboardShiftState.KVKS_SHIFT);
+  assert.equal(vk.keys[185].text, '');
+}

package/test/kvk/test-kvks-file.ts

@@ -0,0 +1,45 @@
+import * as fs from 'fs';
+import 'mocha';
+import { loadKvksJsonSchema, makePathToFixture } from '../helpers/index.js';
+import KvksFileReader, { KVKSParseError } from "../../src/kvk/kvks-file-reader.js";
+import KvksFileWriter from "../../src/kvk/kvks-file-writer.js";
+import { verify_khmer_angkor } from './test-kvk-utils.js';
+import { assert } from 'chai';
+
+describe('kvks-file-reader', function() {
+  it('should read a valid file', function() {
+    const path = makePathToFixture('kvk', 'khmer_angkor.kvks');
+    const input = fs.readFileSync(path);
+
+    const reader = new KvksFileReader();
+    const kvks = reader.read(input);
+    assert.doesNotThrow(() => {
+      reader.validate(kvks, loadKvksJsonSchema());
+    });
+    const errors: KVKSParseError[] = [];
+    const vk = reader.transform(kvks, errors);
+    assert.isEmpty(errors);
+    verify_khmer_angkor(vk);
+  });
+});
+
+describe('kvks-file-writer', function() {
+  it('should write a valid file', function() {
+    const path = makePathToFixture('kvk', 'khmer_angkor.kvks');
+    const input = fs.readFileSync(path);
+
+    const reader = new KvksFileReader();
+    const kvksExpected = reader.read(input);
+    const errors: KVKSParseError[] = [];
+    const vk = reader.transform(kvksExpected, errors);
+    assert.isEmpty(errors);
+
+    const writer = new KvksFileWriter();
+    const output = writer.write(vk);
+
+    // We compare the (re)loaded data, because there may be
+    // minor, irrelevant formatting differences in the emitted xml
+    const kvks = reader.read(Buffer.from(output, 'utf8'));
+    assert.deepEqual(kvks, kvksExpected);
+  });
+});

package/test/ldml-keyboard/test-ldml-keyboard-testdata-reader.ts

@@ -0,0 +1,51 @@
+import { constants } from '@keymanapp/ldml-keyboard-constants';
+import { assert } from 'chai';
+import 'mocha';
+import { testTestdataReaderCases } from '../helpers/reader-callback-test.js';
+
+describe('ldml keyboard xml reader tests', function () {
+  this.slow(500); // 0.5 sec -- json schema validation takes a while
+
+  testTestdataReaderCases([
+    {
+      subpath: 'test-fr.xml',
+      callback: (data, source) => {
+        assert.ok(source);
+        assert.ok(source.keyboardTest);
+        assert.equal(source.keyboardTest.conformsTo, constants.cldr_version_latest);
+
+        assert.deepEqual(source.keyboardTest.info, {
+          keyboard: 'fr-t-k0-azerty.xml',
+          author: 'Team Keyboard',
+          name: 'fr-test'
+        });
+
+        assert.sameDeepMembers(source.keyboardTest.repertoire, [
+          {
+            name: 'simple-repertoire',
+            chars: '[a b c d e \\u{22}]',
+            type: 'simple'
+          },
+          { name: 'chars-repertoire', chars: '[á é ó]', type: 'gesture' }
+        ]);
+
+        assert.equal(1, source.keyboardTest.tests?.length);
+        assert.equal('key-tests', source.keyboardTest.tests[0].name);
+        assert.equal(1, source.keyboardTest.tests[0].test?.length);
+        const test0 = source.keyboardTest.tests[0].test[0];
+        assert.equal('key-test', test0.name);
+        assert.equal('abc\\u0022...', test0.startContext?.to);
+        assert.sameDeepOrderedMembers([
+          { keystroke: { key: 's' } },
+          { check: { result: 'abc\\u0022...s' } },
+          { keystroke: { key: 't' } },
+          { check: { result: 'abc\\u0022...st' } },
+          { keystroke: { key: 'u' } },
+          { check: { result: 'abc\\u0022...stu' } },
+          { emit: { to: 'v' } },
+          { check: { result: 'abc\\u0022...stuv' } },
+        ], test0.actions);
+      },
+    }
+  ]);
+});