sportident.js 1.0.0 → 1.0.2

package/src/testUtils.test.ts

@@ -1,266 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import _ from 'lodash';
-import * as testUtils from './testUtils';
-
-testUtils.useFakeTimers();
-
-describe('testUtils', () => {
-	test('runPromises resolve with fake timers', async () => {
-		const timeState = {
-			promiseResolved: false
-		};
-		Promise.resolve().then(() => {
-			timeState.promiseResolved = true;
-		});
-		expect(timeState).toEqual({ promiseResolved: false });
-		await testUtils.runPromises();
-		expect(timeState).toEqual({ promiseResolved: true });
-	});
-	test('runPromises reject with fake timers', async () => {
-		const timeState = { promiseRejected: false };
-		Promise.reject(new Error('test')).catch(() => {
-			timeState.promiseRejected = true;
-		});
-		expect(timeState).toEqual({ promiseRejected: false });
-		await testUtils.runPromises();
-		expect(timeState).toEqual({ promiseRejected: true });
-	});
-	test('advanceTimersByTime', async () => {
-		const timeState = {
-			timeout0: false,
-			promise0: false,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		};
-		setTimeout(() => {
-			timeState.timeout0 = true;
-		}, 0);
-		setTimeout(() => {
-			timeState.timeout1 = true;
-		}, 1);
-		setTimeout(() => {
-			timeState.timeout2 = true;
-		}, 2);
-		const promise0 = new Promise((resolve) => setTimeout(resolve, 0));
-		const promise1 = new Promise((resolve) => setTimeout(resolve, 1));
-		const promise2 = new Promise((resolve) => setTimeout(resolve, 2));
-		promise0.then(() => {
-			timeState.promise0 = true;
-		});
-		promise1.then(() => {
-			timeState.promise1 = true;
-		});
-		promise2.then(() => {
-			timeState.promise2 = true;
-		});
-		expect(timeState).toEqual({
-			timeout0: false,
-			promise0: false,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({
-			timeout0: true,
-			promise0: true,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		});
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({
-			timeout0: true,
-			promise0: true,
-			timeout1: true,
-			promise1: true,
-			timeout2: false,
-			promise2: false
-		});
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({
-			timeout0: true,
-			promise0: true,
-			timeout1: true,
-			promise1: true,
-			timeout2: true,
-			promise2: true
-		});
-	});
-	test('nTimesAsync', async () => {
-		const timeState = {
-			timeout0: false,
-			promise0: false,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		};
-		setTimeout(() => {
-			timeState.timeout0 = true;
-		}, 0);
-		setTimeout(() => {
-			timeState.timeout1 = true;
-		}, 1);
-		setTimeout(() => {
-			timeState.timeout2 = true;
-		}, 2);
-		const promise0 = new Promise((resolve) => setTimeout(resolve, 0));
-		const promise1 = new Promise((resolve) => setTimeout(resolve, 1));
-		const promise2 = new Promise((resolve) => setTimeout(resolve, 2));
-		promise0.then(() => {
-			timeState.promise0 = true;
-		});
-		promise1.then(() => {
-			timeState.promise1 = true;
-		});
-		promise2.then(() => {
-			timeState.promise2 = true;
-		});
-		expect(timeState).toEqual({
-			timeout0: false,
-			promise0: false,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		});
-		await testUtils.nTimesAsync(0, () => testUtils.advanceTimersByTime(0));
-		expect(timeState).toEqual({
-			timeout0: false,
-			promise0: false,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		});
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
-		expect(timeState).toEqual({
-			timeout0: true,
-			promise0: true,
-			timeout1: false,
-			promise1: false,
-			timeout2: false,
-			promise2: false
-		});
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(1));
-		expect(timeState).toEqual({
-			timeout0: true,
-			promise0: true,
-			timeout1: true,
-			promise1: true,
-			timeout2: true,
-			promise2: true
-		});
-	});
-	test('getRandomInt with 0 options', () => {
-		_.range(10).forEach(() => {
-			expect(testUtils.getRandomInt(0)).toBe(0);
-		});
-	});
-	test('getRandomInt with 1 options', () => {
-		_.range(10).forEach(() => {
-			expect(testUtils.getRandomInt(1)).toBe(0);
-		});
-	});
-	test('getRandomInt with 2 options', () => {
-		_.range(10).forEach(() => {
-			const randomInt = testUtils.getRandomInt(2);
-			expect(randomInt).not.toBeLessThan(0);
-			expect(randomInt).not.toBeGreaterThan(1);
-		});
-	});
-	test('getRandomByte', () => {
-		_.range(10).forEach(() => {
-			const randomByte = testUtils.getRandomByte();
-			expect(randomByte).not.toBeLessThan(0x00);
-			expect(randomByte).not.toBeGreaterThan(0xff);
-			expect(Math.floor(randomByte)).toBe(randomByte);
-		});
-	});
-	test('getRandomByteExcept one', () => {
-		_.range(10).forEach(() => {
-			const randomByte = testUtils.getRandomByteExcept([0x42]);
-			expect(randomByte).not.toBe(0x42);
-			expect(randomByte).not.toBeLessThan(0x00);
-			expect(randomByte).not.toBeGreaterThan(0xff);
-			expect(Math.floor(randomByte)).toBe(randomByte);
-		});
-	});
-	test('getRandomByteExcept all but one', () => {
-		_.range(10).forEach(() => {
-			const randomByte = testUtils.getRandomByteExcept(_.range(255));
-			expect(randomByte).toBe(0xff);
-		});
-	});
-	test('getRandomMessage', () => {
-		_.range(10).forEach(() => {
-			const randomMessage = testUtils.getRandomMessage({});
-			expect(randomMessage.command).not.toBeLessThan(0x00);
-			expect(randomMessage.command).not.toBeGreaterThan(0xff);
-			expect(randomMessage.parameters).toEqual([]);
-		});
-	});
-	test('getRandomMessage with numParameters', () => {
-		_.range(10).forEach(() => {
-			const numParameters = Math.floor(Math.random() * 3 + 1);
-			const randomMessage = testUtils.getRandomMessage({ numParameters: numParameters });
-			expect(randomMessage.command).not.toBeLessThan(0x00);
-			expect(randomMessage.command).not.toBeGreaterThan(0xff);
-			expect(randomMessage.parameters.length).toBe(numParameters);
-			expect(randomMessage.parameters[0]).not.toBeLessThan(0x00);
-			expect(randomMessage.parameters[0]).not.toBeGreaterThan(0xff);
-		});
-	});
-	test('getRandomMessage with command', () => {
-		_.range(10).forEach(() => {
-			const command = testUtils.getRandomByte();
-			const randomMessage = testUtils.getRandomMessage({ command: command });
-			expect(randomMessage.command).toBe(command);
-			expect(randomMessage.parameters).toEqual([]);
-		});
-	});
-	test('getRandomMessage with parameters', () => {
-		_.range(10).forEach(() => {
-			const numParameters = Math.floor(Math.random() * 3 + 1);
-			const parameters = _.range(numParameters).map(() => testUtils.getRandomByte());
-			const randomMessage = testUtils.getRandomMessage({ parameters: parameters });
-			expect(randomMessage.command).not.toBeLessThan(0x00);
-			expect(randomMessage.command).not.toBeGreaterThan(0xff);
-			expect(randomMessage.parameters).toEqual(parameters);
-		});
-	});
-	test('runMock', () => {
-		const mockObject: testUtils.Mockable<string> = {
-			mocks: {
-				existing: (index) => `existing${index}`
-			},
-			counts: {}
-		};
-		const getDefaultResult = (index: number) => `default${index}`;
-
-		const resultExisting1 = testUtils.runMock(mockObject, 'existing', getDefaultResult);
-		expect(resultExisting1).toBe('existing0');
-		expect(mockObject.counts).toEqual({ existing: 1 });
-
-		const resultNonExisting1 = testUtils.runMock(mockObject, 'nonExisting', getDefaultResult);
-		expect(resultNonExisting1).toBe('default0');
-		expect(mockObject.counts).toEqual({ existing: 1, nonExisting: 1 });
-
-		const resultExisting2 = testUtils.runMock(mockObject, 'existing', getDefaultResult);
-		expect(resultExisting2).toBe('existing1');
-		expect(mockObject.counts).toEqual({ existing: 2, nonExisting: 1 });
-
-		const resultNonExisting2 = testUtils.runMock(mockObject, 'nonExisting', getDefaultResult);
-		expect(resultNonExisting2).toBe('default1');
-		expect(mockObject.counts).toEqual({ existing: 2, nonExisting: 2 });
-
-		const resultNonExisting3 = testUtils.runMock(mockObject, 'yetAnother', getDefaultResult);
-		expect(resultNonExisting3).toBe('default0');
-		expect(mockObject.counts).toEqual({ existing: 2, nonExisting: 2, yetAnother: 1 });
-	});
-});

package/src/testUtils.ts

@@ -1,75 +0,0 @@
-/* globals jest */
-
-import _ from 'lodash';
-import type * as siProtocol from './siProtocol';
-import { jest } from '@jest/globals';
-
-export const useFakeTimers = (): void => {
-	jest.useFakeTimers();
-};
-
-export const runPromises = async (): Promise<void> => {
-	await Promise.resolve();
-};
-
-export const advanceTimersByTime = async (msToRun: number): Promise<void> => {
-	jest.advanceTimersByTime(msToRun);
-	await Promise.resolve();
-};
-
-export const nTimesAsync = async (n: number, doThing: () => Promise<unknown>): Promise<void> => {
-	if (n <= 0) {
-		return;
-	}
-	await doThing();
-	await nTimesAsync(n - 1, doThing);
-};
-
-export const getRandomInt = (numOptions: number): number => Math.floor(Math.random() * numOptions);
-
-export const getRandomByte = (): number => getRandomInt(256);
-
-export const getRandomByteExcept = (except: number[]): number => {
-	except.sort((a, b) => Number(a) - Number(b));
-	const numOptions = 256 - except.length;
-	let randomValue = getRandomInt(numOptions);
-	except.forEach((exceptedByte) => {
-		if (randomValue >= exceptedByte) {
-			randomValue += 1;
-		}
-	});
-	return randomValue;
-};
-
-type GetRandomMessageOptions = {
-	command?: number;
-	parameters?: number[];
-	numParameters?: number;
-};
-
-export const getRandomMessage = (options: GetRandomMessageOptions): siProtocol.SiMessageWithoutMode => {
-	let command = getRandomByte();
-	if (options.command !== undefined) {
-		command = options.command;
-	}
-	let parameters: number[] = [];
-	if (options.parameters !== undefined) {
-		parameters = options.parameters;
-	} else if (options.numParameters !== undefined) {
-		parameters = _.range(options.numParameters).map(() => getRandomByte());
-	}
-	return { command: command, parameters: parameters };
-};
-
-export interface Mockable<T> {
-	counts: { [key: string]: number };
-	mocks: { [key: string]: (count: number) => T };
-}
-
-export const runMock = <T>(that: Mockable<T>, key: string, getDefaultResult: (count: number) => T): T => {
-	const count = that.counts[key] || 0;
-	const mockFunction = that.mocks[key] || getDefaultResult;
-	const result = mockFunction(count);
-	that.counts[key] = count + 1;
-	return result;
-};

package/src/utils/NumberRange.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { NumberRange } from './NumberRange';
-
-describe('NumberRange utils', () => {
-	test('instance', () => {
-		const numberRange = new NumberRange(0, 100);
-		expect(numberRange.start).toBe(0);
-		expect(numberRange.end).toBe(100);
-	});
-	test('null range', () => {
-		expect(() => new NumberRange(0, 0)).toThrow();
-		expect(() => new NumberRange(100, 100)).toThrow();
-	});
-	test('reverse range', () => {
-		expect(() => new NumberRange(100, 0)).toThrow();
-	});
-	const numberRange = new NumberRange(-3, 3);
-	test('toString', () => {
-		expect(numberRange.toString()).toBe('NumberRange(-3, 3)');
-	});
-	test('contains', () => {
-		expect(numberRange.contains(-4)).toBe(false);
-		expect(numberRange.contains(-3)).toBe(true);
-		expect(numberRange.contains(2)).toBe(true);
-		expect(numberRange.contains(3)).toBe(false);
-	});
-	test('isEntirelyAfter number', () => {
-		expect(numberRange.isEntirelyAfter(-4)).toBe(true);
-		expect(numberRange.isEntirelyAfter(-3)).toBe(false);
-		expect(numberRange.isEntirelyAfter(1)).toBe(false);
-		expect(numberRange.isEntirelyAfter(3)).toBe(false);
-	});
-	test('isEntirelyBefore number', () => {
-		expect(numberRange.isEntirelyBefore(-4)).toBe(false);
-		expect(numberRange.isEntirelyBefore(-3)).toBe(false);
-		expect(numberRange.isEntirelyBefore(1)).toBe(false);
-		expect(numberRange.isEntirelyBefore(3)).toBe(true);
-	});
-	const numberRange1 = new NumberRange(-4, -3);
-	const numberRange2 = new NumberRange(-3, 3);
-	const numberRange3 = new NumberRange(2, 4);
-	test('intersects', () => {
-		expect(numberRange1.intersects(numberRange2)).toBe(false);
-		expect(numberRange2.intersects(numberRange1)).toBe(false);
-		expect(numberRange2.intersects(numberRange3)).toBe(true);
-		expect(numberRange3.intersects(numberRange2)).toBe(true);
-		expect(numberRange1.intersects(numberRange3)).toBe(false);
-		expect(numberRange3.intersects(numberRange1)).toBe(false);
-	});
-	test('isEntirelyAfter range', () => {
-		expect(numberRange1.isEntirelyAfter(numberRange2)).toBe(false);
-		expect(numberRange2.isEntirelyAfter(numberRange1)).toBe(true);
-		expect(numberRange2.isEntirelyAfter(numberRange3)).toBe(false);
-		expect(numberRange3.isEntirelyAfter(numberRange2)).toBe(false);
-		expect(numberRange1.isEntirelyAfter(numberRange3)).toBe(false);
-		expect(numberRange3.isEntirelyAfter(numberRange1)).toBe(true);
-	});
-	test('isEntirelyBefore range', () => {
-		expect(numberRange1.isEntirelyBefore(numberRange2)).toBe(true);
-		expect(numberRange2.isEntirelyBefore(numberRange1)).toBe(false);
-		expect(numberRange2.isEntirelyBefore(numberRange3)).toBe(false);
-		expect(numberRange3.isEntirelyBefore(numberRange2)).toBe(false);
-		expect(numberRange1.isEntirelyBefore(numberRange3)).toBe(true);
-		expect(numberRange3.isEntirelyBefore(numberRange1)).toBe(false);
-	});
-});

package/src/utils/NumberRange.ts

@@ -1,46 +0,0 @@
-import Immutable from 'immutable';
-
-export class NumberRange extends Immutable.Record({
-	start: 0,
-	end: 0
-}) {
-	constructor(start: number, end: number) {
-		if (!(start < end)) {
-			throw new Error(`Invalid NumberRange(${start}, ${end})`);
-		}
-		super({
-			start: start,
-			end: end
-		});
-	}
-
-	toString(): string {
-		return `NumberRange(${this.start}, ${this.end})`;
-	}
-
-	contains(number: number): boolean {
-		return number >= this.start && number < this.end;
-	}
-
-	isEntirelyAfter(otherRangeOrNumber: NumberRange | number): boolean {
-		if (otherRangeOrNumber instanceof NumberRange) {
-			const otherRange = otherRangeOrNumber;
-			return otherRange.end <= this.start;
-		}
-		const otherNumber = otherRangeOrNumber;
-		return otherNumber < this.start;
-	}
-
-	isEntirelyBefore(otherRangeOrNumber: NumberRange | number): boolean {
-		if (otherRangeOrNumber instanceof NumberRange) {
-			const otherRange = otherRangeOrNumber;
-			return otherRange.start >= this.end;
-		}
-		const otherNumber = otherRangeOrNumber;
-		return otherNumber >= this.end;
-	}
-
-	intersects(otherRange: NumberRange): boolean {
-		return !this.isEntirelyAfter(otherRange) && !this.isEntirelyBefore(otherRange);
-	}
-}

package/src/utils/NumberRangeRegistry.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { NumberRange } from './NumberRange';
-import { NumberRangeRegistry } from './NumberRangeRegistry';
-
-describe('NumberRangeRegistry utils', () => {
-	const numberRange1 = new NumberRange(-4, -3);
-	const numberRange2 = new NumberRange(-3, 3);
-	const numberRange3 = new NumberRange(3, 4);
-	const numberRange23 = new NumberRange(2, 4);
-	test('can register new range', () => {
-		const numberRangeRegistry = new NumberRangeRegistry();
-		numberRangeRegistry.register(numberRange2, 2);
-		expect(numberRangeRegistry.numberRanges.size).toEqual(1);
-		expect(numberRangeRegistry.numberRanges.get(0)).toEqual(numberRange2);
-		expect(numberRangeRegistry.values.size).toEqual(1);
-		expect(numberRangeRegistry.values.get(0)).toEqual(2);
-	});
-	test('registers ranges in right order', () => {
-		const numberRangeRegistry = new NumberRangeRegistry();
-		numberRangeRegistry.register(numberRange2, 2);
-		numberRangeRegistry.register(numberRange1, 1);
-		numberRangeRegistry.register(numberRange3, 3);
-		expect(numberRangeRegistry.numberRanges.size).toEqual(3);
-		expect(numberRangeRegistry.numberRanges.get(0)).toEqual(numberRange1);
-		expect(numberRangeRegistry.numberRanges.get(1)).toEqual(numberRange2);
-		expect(numberRangeRegistry.numberRanges.get(2)).toEqual(numberRange3);
-		expect(numberRangeRegistry.values.size).toEqual(3);
-		expect(numberRangeRegistry.values.get(0)).toEqual(1);
-		expect(numberRangeRegistry.values.get(1)).toEqual(2);
-		expect(numberRangeRegistry.values.get(2)).toEqual(3);
-	});
-	test('refuses to register overlapping range', () => {
-		const numberRangeRegistry = new NumberRangeRegistry();
-		numberRangeRegistry.register(numberRange2, 2);
-		expect(() => numberRangeRegistry.register(numberRange23, 1)).toThrow();
-	});
-	test('gets the value for a number', () => {
-		const numberRangeRegistry = new NumberRangeRegistry();
-		numberRangeRegistry.register(numberRange1, 1);
-		numberRangeRegistry.register(numberRange3, 3);
-		numberRangeRegistry.register(numberRange2, 2);
-		expect(numberRangeRegistry.getValueForNumber(-5)).toEqual(undefined);
-		expect(numberRangeRegistry.getValueForNumber(-4)).toEqual(1);
-		expect(numberRangeRegistry.getValueForNumber(-3)).toEqual(2);
-		expect(numberRangeRegistry.getValueForNumber(2)).toEqual(2);
-		expect(numberRangeRegistry.getValueForNumber(3)).toEqual(3);
-		expect(numberRangeRegistry.getValueForNumber(4)).toEqual(undefined);
-	});
-});

package/src/utils/NumberRangeRegistry.ts

@@ -1,43 +0,0 @@
-import Immutable from 'immutable';
-import * as generalUtils from './general';
-import type { NumberRange } from './NumberRange';
-
-export class NumberRangeRegistry<T> {
-	public numberRanges: Immutable.List<NumberRange> = Immutable.List();
-	public values: Immutable.List<T> = Immutable.List();
-
-	register(numberRange: NumberRange, value: T): void {
-		const index = generalUtils.binarySearch(this.numberRanges, numberRange, {
-			getLength: (numberRanges) => numberRanges.size,
-			getNewRange: (numberRanges, numberRangeToInsert, start, end) => {
-				const mid = Math.floor((start + end) / 2);
-				const midNumberRange = numberRanges.get(mid)!;
-				const isEntirelyBeforeMid = numberRangeToInsert.isEntirelyBefore(midNumberRange);
-				const isEntirelyAfterMid = numberRangeToInsert.isEntirelyAfter(midNumberRange);
-				if (!isEntirelyBeforeMid && !isEntirelyAfterMid) {
-					throw new Error(`Refusing to insert ${numberRangeToInsert.toString()} ` + `next to ${midNumberRange.toString()}`);
-				}
-				return isEntirelyBeforeMid ? [start, mid] : [mid + 1, end];
-			}
-		});
-		this.numberRanges = this.numberRanges.insert(index, numberRange);
-		this.values = this.values.insert(index, value);
-	}
-
-	getValueForNumber(number: number): T | undefined {
-		const index = generalUtils.binarySearch(this.numberRanges, number, {
-			getLength: (numberRanges) => numberRanges.size,
-			getNewRange: (numberRanges, number_, start, end) => {
-				const mid = Math.floor((start + end) / 2);
-				const midNumberRange = numberRanges.get(mid)!;
-				const isBeforeOrInMid = !midNumberRange.isEntirelyBefore(number_);
-				return isBeforeOrInMid ? [start, mid] : [mid + 1, end];
-			}
-		});
-		const numberRangeAtIndex = this.numberRanges.get(index);
-		if (numberRangeAtIndex !== undefined && numberRangeAtIndex.contains(number)) {
-			return this.values.get(index);
-		}
-		return undefined;
-	}
-}

package/src/utils/bytes.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import * as byteUtils from './bytes';
-
-describe('byte utils', () => {
-	const bytes = [0, 0x01, 0x001, 156, 0xff];
-	const nonBytes = [-1, 0x100, 0.5, 'asdf', '0xFF', false, true, [], {}, undefined, null];
-	test('isByte works', () => {
-		bytes.forEach((byte) => {
-			expect(byteUtils.isByte(byte)).toBe(true);
-		});
-		nonBytes.forEach((nonByte) => {
-			expect(byteUtils.isByte(nonByte)).toBe(false);
-		});
-	});
-	test('isByteArr works', () => {
-		expect(byteUtils.isByteArr([])).toBe(true);
-		bytes.forEach((byte) => {
-			expect(byteUtils.isByteArr([byte])).toBe(true);
-		});
-		nonBytes.forEach((nonByte) => {
-			expect(byteUtils.isByteArr([nonByte])).toBe(false);
-		});
-	});
-	test('assertIsByteArr works', () => {
-		expect(() => byteUtils.assertIsByteArr([])).not.toThrow();
-		bytes.forEach((byte) => {
-			expect(() => byteUtils.assertIsByteArr([byte])).not.toThrow();
-		});
-		nonBytes.forEach((nonByte) => {
-			expect(() => byteUtils.assertIsByteArr([nonByte])).toThrow();
-		});
-	});
-	test('isArrOfLengths works', () => {
-		expect(byteUtils.isArrOfLengths([], [])).toBe(false);
-		expect(byteUtils.isArrOfLengths([], [0])).toBe(true);
-		expect(byteUtils.isArrOfLengths([], [1])).toBe(false);
-		expect(byteUtils.isArrOfLengths([], [0, 1])).toBe(true);
-		expect(byteUtils.isArrOfLengths([], [1, 2])).toBe(false);
-		expect(byteUtils.isArrOfLengths([1], [])).toBe(false);
-		expect(byteUtils.isArrOfLengths([1], [0])).toBe(false);
-		expect(byteUtils.isArrOfLengths([1], [1])).toBe(true);
-		expect(byteUtils.isArrOfLengths([1], [0, 1])).toBe(true);
-		expect(byteUtils.isArrOfLengths([1], [1, 2])).toBe(true);
-	});
-	test('assertArrIsOfLengths works', () => {
-		expect(() => byteUtils.assertArrIsOfLengths([], [])).toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([], [0])).not.toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([], [1])).toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([], [0, 1])).not.toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([], [1, 2])).toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([1], [])).toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([1], [0])).toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([1], [1])).not.toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([1], [0, 1])).not.toThrow();
-		expect(() => byteUtils.assertArrIsOfLengths([1], [1, 2])).not.toThrow();
-	});
-	test('arr2big works', () => {
-		expect(byteUtils.arr2big([])).toBe(0x00);
-		expect(byteUtils.arr2big([0x00])).toBe(0x00);
-		expect(byteUtils.arr2big([0x001])).toBe(0x01);
-		expect(byteUtils.arr2big([0x00, 0x00])).toBe(0x0000);
-		expect(byteUtils.arr2big([0x12])).toBe(0x12);
-		expect(byteUtils.arr2big([0x12, 0x34])).toBe(0x1234);
-		expect(byteUtils.arr2big([0x12, 0x34, 0x56, 0xaf])).toBe(0x123456af);
-		expect(byteUtils.arr2big([0xff])).toBe(0xff);
-		expect(byteUtils.arr2big([0xff, 0xff])).toBe(0xffff);
-	});
-	test('arr2big sanitizes', () => {
-		expect(() => byteUtils.arr2big([0x100])).toThrow();
-		expect(() => byteUtils.arr2big([0x123])).toThrow();
-		expect(() => byteUtils.arr2big([0x123456])).toThrow();
-		expect(() => byteUtils.arr2big([0xff, 0x100])).toThrow();
-		expect(() => byteUtils.arr2big([0xff, 0x100])).toThrow();
-		expect(() => byteUtils.arr2big([2.5])).toThrow();
-	});
-	test('prettyHex without lineLength', () => {
-		expect(byteUtils.prettyHex([])).toBe('');
-		expect(byteUtils.prettyHex([0x00])).toBe('00');
-		expect(byteUtils.prettyHex([0xff])).toBe('FF');
-		expect(byteUtils.prettyHex([0x00, 0x00])).toBe('00 00');
-		expect(byteUtils.prettyHex([0x00, 0x00, 0x00])).toBe('00 00 00');
-		expect(byteUtils.prettyHex([0x12, 0x34, 0x00])).toBe('12 34 00');
-		expect(byteUtils.prettyHex([0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10])).toBe('FE DC BA 98 76 54 32 10');
-		expect(byteUtils.prettyHex('')).toBe('');
-		expect(byteUtils.prettyHex('a')).toBe('61');
-		expect(byteUtils.prettyHex('AA')).toBe('41 41');
-		expect(byteUtils.prettyHex('000')).toBe('30 30 30');
-		expect(byteUtils.prettyHex('    ')).toBe('20 20 20 20');
-		expect(byteUtils.prettyHex([0xfff])).toBe('FF');
-		expect(byteUtils.prettyHex([undefined])).toBe('??');
-	});
-	test('prettyHex with lineLength', () => {
-		expect(byteUtils.prettyHex('', 0)).toBe('');
-		expect(byteUtils.prettyHex('1', 0)).toBe('31');
-		expect(byteUtils.prettyHex('12345678', 0)).toBe('31 32 33 34 35 36 37 38');
-		expect(byteUtils.prettyHex('', 1)).toBe('');
-		expect(byteUtils.prettyHex('1', 1)).toBe('31');
-		expect(byteUtils.prettyHex('12345678', 1)).toBe('31\n32\n33\n34\n35\n36\n37\n38');
-		expect(byteUtils.prettyHex('', 4)).toBe('');
-		expect(byteUtils.prettyHex('1', 4)).toBe('31');
-		expect(byteUtils.prettyHex('123', 4)).toBe('31 32 33');
-		expect(byteUtils.prettyHex('1234', 4)).toBe('31 32 33 34');
-		expect(byteUtils.prettyHex('12345', 4)).toBe('31 32 33 34\n35');
-		expect(byteUtils.prettyHex('1234567', 4)).toBe('31 32 33 34\n35 36 37');
-		expect(byteUtils.prettyHex('12345678', 4)).toBe('31 32 33 34\n35 36 37 38');
-		expect(byteUtils.prettyHex('123456789', 4)).toBe('31 32 33 34\n35 36 37 38\n39');
-		expect(byteUtils.prettyHex([0xfff], 4)).toBe('FF');
-		expect(byteUtils.prettyHex([undefined], 4)).toBe('??');
-	});
-	test('unPrettyHex', () => {
-		expect(byteUtils.unPrettyHex('')).toEqual([]);
-		expect(byteUtils.unPrettyHex('31')).toEqual([0x31]);
-		expect(byteUtils.unPrettyHex('31 32')).toEqual([0x31, 0x32]);
-		expect(byteUtils.unPrettyHex('31 32 33 34\n35')).toEqual([0x31, 0x32, 0x33, 0x34, 0x35]);
-		expect(byteUtils.unPrettyHex('00 FF ff')).toEqual([0x00, 0xff, 0xff]);
-
-		expect(byteUtils.unPrettyHex('??')).toEqual([undefined]);
-		expect(byteUtils.unPrettyHex('31 ??')).toEqual([0x31, undefined]);
-		expect(byteUtils.unPrettyHex('?? 32')).toEqual([undefined, 0x32]);
-		expect(byteUtils.unPrettyHex('?? ??')).toEqual([undefined, undefined]);
-		expect(byteUtils.unPrettyHex('??\n??')).toEqual([undefined, undefined]);
-
-		expect(() => byteUtils.unPrettyHex('1')).toThrow();
-		expect(() => byteUtils.unPrettyHex('GG')).toThrow();
-	});
-});