Merge pull request #1105 from mathjax/util-tests

Add tests for all ts/util files and update some utils to fix issues found from tests

Author: dpvc

.gitignore

@@ -7,4 +7,4 @@ coverage
 /mjs
 /bundle
 /bundle-cjs
-
+/testsuite/js

testsuite/jest.config.ts

@@ -14,6 +14,7 @@ const config: Config = {
   collectCoverage: true,
   coverageDirectory: "coverage",
   coverageProvider: "v8",
+  coveragePathIgnorePatterns: ["node_modules", "testsuite", "mjs/util/entities"],
   testEnvironment: "node",
   verbose: true,
   preset: tsjest,

testsuite/lib/AsyncLoad.child.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+  loaded: true
+};

testsuite/lib/AsyncLoad.child.mjs

@@ -0,0 +1 @@
+export const loaded = true;

testsuite/src/dirname.ts

@@ -0,0 +1,6 @@
+declare var __dirname: string;
+
+export function setDirname(name: string) {
+  __dirname = name;
+}
+

testsuite/tests/util/AsyncLoad.test.ts

@@ -0,0 +1,39 @@
+import { describe, test, expect } from '@jest/globals';
+import {asyncLoad} from '#js/util/AsyncLoad.js';
+import {mathjax} from '#js/mathjax.js';
+
+describe('asyncLoad()', () => {
+
+  test('asyncLoad()', async () => {
+    //
+    // Throws error if not set in mathjax
+    //
+    expect(asyncLoad('x.js').then(() => false).catch(() => true)).resolves.toBe(true);
+
+    //
+    // mathjax.asyncLoad returns value
+    //
+    mathjax.asyncLoad = (_name: string) => 'success';
+    await expect(asyncLoad('x.js')).resolves.toBe('success');
+
+    //
+    // mathjax.asyncLoad throws error
+    //
+    mathjax.asyncLoad = (_name: string) => {throw 'fail'};
+    await expect(asyncLoad('x.js')).rejects.toBe('fail');
+
+    //
+    // mathjax.asyncLoad returns promise
+    //
+    mathjax.asyncLoad = (_name: string) => Promise.resolve().then(() => 'success');
+    await expect(asyncLoad('x.js')).resolves.toBe('success');
+
+    //
+    // mathjax.asyncLoad returns promise that rejects
+    //
+    mathjax.asyncLoad = (_name: string) => Promise.reject().catch(() => {throw 'fail'});
+    await expect(asyncLoad('x.js')).rejects.toBe('fail');
+
+  });
+
+});

testsuite/tests/util/BBox.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect } from '@jest/globals';
+import {BBox} from '#js/util/BBox.js';
+import {BIGDIMEN} from '#js/util/lengths.js';
+
+describe('BBox object', () => {
+
+  test('BBox creation', () => {
+    expect(BBox.zero()).toEqual(expect.objectContaining({w: 0, h: 0, d: 0}));
+    expect(BBox.empty()).toEqual(expect.objectContaining({w: 0, h: -BIGDIMEN, d: -BIGDIMEN}));
+    expect(new BBox({w: 1, h: 2, d: 0})).toEqual({
+      w: 1, h: 2, d: 0,
+      L: 0, R: 0,
+      ic: 0, oc: 0, sk: 0, dx: 0,
+      scale: 1, rscale: 1,
+      pwidth: ''
+    });
+    expect(new BBox({w: 1})).toEqual(expect.objectContaining({w: 1, h: -BIGDIMEN, d: -BIGDIMEN}));
+  });
+
+  test('empty()', () => {
+    expect(BBox.zero().empty()).toEqual(expect.objectContaining({w: 0, h: -BIGDIMEN, d: -BIGDIMEN}));
+  });
+
+  test('clean()', () => {
+    const bbox = BBox.empty();
+    bbox.w = -BIGDIMEN;
+    bbox.clean();
+    expect(bbox).toEqual(expect.objectContaining({w: 0, h: 0, d: 0}));
+  });
+
+  test('rescale()', () => {
+    const bbox = new BBox({w: 1, h: 2, d: 3});
+    bbox.rescale(2);
+    expect(bbox).toEqual(expect.objectContaining({w: 2, h: 4, d: 6}));
+    bbox.rescale(0);
+    expect(bbox).toEqual(BBox.zero());
+  });
+
+  test('copy()', () => {
+    const bbox = Object.assign(new BBox({w: 1, h: 2, d: 3}), {
+      L: 4, R: 5,
+      ic: 6, oc: 7, sk: 8, dx: 9,
+      scale: 10, rscale: 11,
+      pwidth: '10%'
+    });
+    const copy = bbox.copy();
+    expect(copy).toEqual(bbox);
+    expect(copy).not.toBe(bbox);
+  });
+
+  test('updateFrom()', () => {
+    const bbox1 = Object.assign(new BBox({w: 1, h: 2, d: 3}), {
+      L: 4, R: 5,
+      ic: 6, oc: 7, sk: 8, dx: 9,
+      scale: 10, rscale: 11,
+      pwidth: ''
+    });
+    bbox1.updateFrom(BBox.empty());
+    expect(bbox1).toEqual({
+      w: 0, h: -BIGDIMEN, d: -BIGDIMEN,
+      L: 4, R: 5,
+      ic: 6, oc: 7, sk: 8, dx: 9,
+      scale: 10, rscale: 11,
+      pwidth: ''
+    });
+    bbox1.pwidth = '100%';
+    const bbox2 = BBox.zero();
+    bbox2.updateFrom(bbox1);
+    expect(bbox2).toEqual({
+      w: 0, h: -BIGDIMEN, d: -BIGDIMEN,
+      L: 0, R: 0,
+      ic: 0, oc: 0, sk: 0, dx: 0,
+      scale: 1, rscale: 1,
+      pwidth: '100%'
+    });
+  });
+
+  test('combine()', () => {
+    let bbox = BBox.empty();
+    const cbox = new BBox({w: 1, h: 2, d: 3});
+    bbox.combine(cbox);
+    expect(bbox).toEqual(expect.objectContaining({w: 1, h: 2, d: 3}));
+
+    //
+    //  Check that a scaled bbox is placed properly
+    //
+    cbox.rscale = 2;
+    bbox.combine(cbox);
+    expect(bbox).toEqual(expect.objectContaining({w: 2, h: 4, d: 6}));
+
+    //
+    //  Check x and y positioning
+    //
+    bbox = BBox.empty();
+    cbox.L = 2;
+    cbox.R = 1;
+    cbox.rscale = .5;
+    bbox.combine(cbox, 1, 2);
+    expect(bbox).toEqual(expect.objectContaining({w: 3, h: 3, d: -.5}));
+
+    //
+    //  Check box that doesn't change current bbox
+    //
+    cbox.rscale = .01;
+    bbox.combine(cbox, 1, 1);
+    expect(bbox).toEqual(expect.objectContaining({w: 3, h: 3, d: -.5}));
+  });
+
+  test('append()', () => {
+    let bbox = BBox.empty();
+    const cbox = new BBox({w: 1, h: 2, d: 3});
+    bbox.append(cbox);
+    expect(bbox).toEqual(expect.objectContaining({w: 1, h: 2, d: 3}));
+
+    //
+    //  Check that a scaled bbox is placed properly
+    //
+    cbox.rscale = 2;
+    bbox.append(cbox);
+    expect(bbox).toEqual(expect.objectContaining({w: 3, h: 4, d: 6}));
+
+    //
+    //  Check that h and d don't change
+    //
+    cbox.rscale = 1;
+    bbox.append(cbox);
+    expect(bbox).toEqual(expect.objectContaining({w: 4, h: 4, d: 6}));
+  });
+
+});

testsuite/tests/util/BitField.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect } from '@jest/globals';
+import {BitField, BitFieldClass} from '#js/util/BitField.js';
+
+const MAXBIT = (BitField as any).MAXBIT;
+
+const bitClass = BitFieldClass('a', 'b');
+bitClass.allocate('c');
+
+describe('BitField object', () => {
+
+  test('Allocating bits', () => {
+    expect(bitClass.has('a')).toBe(true);
+    expect(bitClass.has('b')).toBe(true);
+    expect(bitClass.has('c')).toBe(true);
+    expect(() => bitClass.allocate('a')).toThrow('Bit already allocated for a');
+    for (let i = 1 << 3; i !== MAXBIT; i = i << 1) {
+      bitClass.allocate('x' + i);
+    }
+    expect(() => bitClass.allocate('y')).toThrow('Maximum number of bits already allocated');
+  });
+
+  test('set/clear/isSet/reset', () => {
+    const bits = new bitClass();
+    //
+    //  Bit is initially false
+    //
+    expect(bits.isSet('a')).toBe(false);
+    expect(bits.isSet('b')).toBe(false);
+    //
+    //  Check that it sets
+    //
+    bits.set('a');
+    expect(bits.isSet('a')).toBe(true);
+    expect(bits.isSet('b')).toBe(false);
+    //
+    //  Check that setting again is still set
+    //
+    bits.set('a')
+    expect(bits.isSet('a')).toBe(true);
+    //
+    //  Check that it clears
+    //
+    bits.clear('a');
+    expect(bits.isSet('a')).toBe(false);
+    //
+    //  Check that it stays clear
+    //
+    bits.clear('a');
+    expect(bits.isSet('a')).toBe(false);
+    //
+    //  Check that reset clears all bits
+    //
+    bits.set('a');
+    bits.set('b');
+    expect(bits.isSet('a')).toBe(true);
+    expect(bits.isSet('b')).toBe(true);
+    bits.reset();
+    expect(bits.isSet('a')).toBe(false);
+    expect(bits.isSet('b')).toBe(false);
+    //
+    //  Invalid name throws error
+    //
+    expect(() => bits.isSet('A')).toThrow('Unknown bit-field name: A');
+  });
+
+});

testsuite/tests/util/Entities.test.ts

@@ -0,0 +1,21 @@
+import { describe, test, expect } from '@jest/globals';
+import * as Entities from '#js/util/Entities.js';
+import {handleRetriesFor} from '#js/util/Retries.js';
+import '#js/util/asyncLoad/esm.js';
+
+describe('Entities translation', () => {
+
+  test('translate()', async () => {
+    expect(Entities.translate('a')).toBe('a');
+    expect(Entities.translate('a')).toBe('a');
+    expect(Entities.translate('&')).toBe('&');
+    await expect(handleRetriesFor(() => Entities.translate('&xyz;'))).resolves.toBe('&xyz;');     // no such entity
+    await expect(handleRetriesFor(() => Entities.translate('≈'))).resolves.toBe('\u2248'); // load a.js
+    await expect(handleRetriesFor(() => Entities.translate('ℬ'))).resolves.toBe('\u212C');   // load scr.js
+    Entities.remove('approx');
+    expect(Entities.translate('≈')).toBe('≈');      // undefined entities remain unchanged
+    Entities.options.loadMissingEntities = false;
+    expect(Entities.translate('⋀')).toBe('⋀');  // don't load b.js
+  });
+
+});