sportident.js 1.0.0

package/src/testUtils.test.ts

@@ -0,0 +1,266 @@
+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

@@ -0,0 +1,75 @@
+/* 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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,126 @@
+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();
+	});
+});