sportident.js 1.0.0

package/src/siProtocol.test.ts

@@ -0,0 +1,509 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import Immutable from 'immutable';
+import { proto } from './constants';
+import * as utils from './utils';
+import * as storage from './storage';
+import * as testUtils from './testUtils';
+import * as siProtocol from './siProtocol';
+
+const json2date = (str: string): Date | undefined => {
+	const res = /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})\.([0-9]{3})Z$/.exec(str);
+	if (!res) {
+		return undefined;
+	}
+	return new Date(Number(res[1]!), Number(res[2]!) - 1, Number(res[3]!), Number(res[4]!), Number(res[5]!), Number(res[6]!), Number(res[7]!));
+};
+
+const date2json = (date: Date | undefined): string | undefined => {
+	if (!date) {
+		return undefined;
+	}
+	const year = date.getFullYear();
+	const month = date.getMonth();
+	const day = date.getDate();
+	const hours = date.getHours();
+	const minutes = date.getMinutes();
+	const seconds = date.getSeconds();
+	const milliseconds = date.getMilliseconds();
+	return new Date(Date.UTC(year, month, day, hours, minutes, seconds, milliseconds)).toJSON();
+};
+
+export const getValidButIncompleteMessageBytes = (): number[][] => {
+	const cutOffCommands: number[][] = [];
+	const appendCutOffCommands = (command: number[]) => {
+		_.range(command.length).forEach((cutOffLength) => {
+			cutOffCommands.push(command.slice(0, cutOffLength));
+		});
+	};
+	const getRandomMessageBytes = (numParameters: number): number[] => siProtocol.render(testUtils.getRandomMessage({ numParameters: numParameters }));
+	appendCutOffCommands(getRandomMessageBytes(0));
+	appendCutOffCommands(getRandomMessageBytes(1));
+	appendCutOffCommands(getRandomMessageBytes(2));
+	return cutOffCommands;
+};
+
+describe('siProtocol', () => {
+	const asOf = new Date('2020-01-01T00:00:00.000Z');
+	test('arr2date works', () => {
+		expect(date2json(siProtocol.arr2date([0x00, 0x01, 0x01], asOf))).toBe('2000-01-01T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x01, 0x02, 0x03], asOf))).toBe('2001-02-03T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x01, 0x0c, 0x1f], asOf))).toBe('2001-12-31T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x14, 0x0c, 0x1f], asOf))).toBe('2020-12-31T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x15, 0x01, 0x01], asOf))).toBe('1921-01-01T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x63, 0x0c, 0x1f], asOf))).toBe('1999-12-31T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x00, 0x01, 0x01, 0x00, 0x00, 0x00], asOf))).toBe('2000-01-01T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x14, 0x0c, 0x1f, 0x01, 0x00, 0x00], asOf))).toBe('2020-12-31T12:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x15, 0x0c, 0x1f, 0x01, 0x00, 0x00], asOf))).toBe('1921-12-31T12:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x63, 0x0c, 0x1f, 0x01, 0x00, 0x00], asOf))).toBe('1999-12-31T12:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x00, 0x01, 0x01, 0x00, 0xa8, 0xbf], asOf))).toBe('2000-01-01T11:59:59.000Z');
+		expect(date2json(siProtocol.arr2date([0x63, 0x0c, 0x1f, 0x01, 0xa8, 0xbf], asOf))).toBe('1999-12-31T23:59:59.000Z');
+		expect(date2json(siProtocol.arr2date([0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00], asOf))).toBe('2000-01-01T00:00:00.000Z');
+		expect(date2json(siProtocol.arr2date([0x14, 0x0c, 0x1f, 0x01, 0x00, 0x00, 0x20], asOf))).toBe('2020-12-31T12:00:00.125Z');
+		expect(date2json(siProtocol.arr2date([0x15, 0x0c, 0x1f, 0x01, 0x00, 0x00, 0x60], asOf))).toBe('1921-12-31T12:00:00.375Z');
+		expect(date2json(siProtocol.arr2date([0x63, 0x0c, 0x1f, 0x01, 0x00, 0x00, 0x80], asOf))).toBe('1999-12-31T12:00:00.500Z');
+		expect(date2json(siProtocol.arr2date([0x00, 0x01, 0x01, 0x00, 0xa8, 0xbf, 0x40], asOf))).toBe('2000-01-01T11:59:59.250Z');
+		expect(date2json(siProtocol.arr2date([0x63, 0x0c, 0x1f, 0x01, 0xa8, 0xbf, 0xc0], asOf))).toBe('1999-12-31T23:59:59.750Z');
+	});
+	test('arr2date sanitizes', () => {
+		expect(() => siProtocol.arr2date([], asOf)).toThrow();
+		expect(() => siProtocol.arr2date([0x100], asOf)).toThrow();
+		expect(() => siProtocol.arr2date([0x123, 0x123], asOf)).toThrow();
+		expect(() => siProtocol.arr2date([1, 2, 3, 4], asOf)).toThrow();
+		expect(() => siProtocol.arr2date([1, 2, 3, 4, 5], asOf)).toThrow();
+		expect(() => siProtocol.arr2date([1, 2, 3, 4, 5, 6, 7, 8], asOf)).toThrow();
+		expect(siProtocol.arr2date([100, 1, 1], asOf)).toBe(undefined);
+		expect(siProtocol.arr2date([0xff, 1, 1], asOf)).toBe(undefined);
+		expect(siProtocol.arr2date([12, 0, 1], asOf)).toBe(undefined);
+		expect(siProtocol.arr2date([12, 13, 1], asOf)).toBe(undefined);
+		expect(siProtocol.arr2date([12, 0xff, 1], asOf)).toBe(undefined);
+	});
+	test('arr2date without asOf', () => {
+		expect(date2json(siProtocol.arr2date([0x00, 0x01, 0x01]))).toBe('2000-01-01T00:00:00.000Z');
+	});
+	test('date2arr', () => {
+		expect(siProtocol.date2arr(json2date('2000-01-01T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x01, 0x0c, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-01T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x01, 0x0d, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-02T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-02T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-03T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x03, 0x02, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-03T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x03, 0x03, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-04T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-04T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x04, 0x05, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-05T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x05, 0x06, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-05T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x05, 0x07, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-06T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x06, 0x08, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-06T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x06, 0x09, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-07T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x07, 0x0a, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2000-01-07T12:00:00.000Z')!)).toEqual([0x00, 0x01, 0x07, 0x0b, 0x00, 0x00, 0x00]);
+		expect(siProtocol.date2arr(json2date('2099-12-31T12:00:00.500Z')!)).toEqual([0x63, 0x0c, 0x1f, 0x09, 0x00, 0x00, 0x80]);
+		expect(siProtocol.date2arr(json2date('2000-01-01T11:59:59.250Z')!)).toEqual([0x00, 0x01, 0x01, 0x0c, 0xa8, 0xbf, 0x40]);
+		expect(siProtocol.date2arr(json2date('1999-12-31T23:59:59.750Z')!)).toEqual([0x63, 0x0c, 0x1f, 0x0b, 0xa8, 0xbf, 0xc0]);
+	});
+	test('date2arr and arr2date do the reverse', () => {
+		const forthAndBack = (date: Date) => siProtocol.arr2date(siProtocol.date2arr(date), asOf);
+		const forthAndBackAsJson = (str: string) => date2json(forthAndBack(json2date(str)!));
+		expect(forthAndBackAsJson('2000-01-01T00:00:00.000Z')).toBe('2000-01-01T00:00:00.000Z');
+		expect(forthAndBackAsJson('2001-02-03T00:00:00.000Z')).toBe('2001-02-03T00:00:00.000Z');
+		expect(forthAndBackAsJson('2001-12-31T00:00:00.000Z')).toBe('2001-12-31T00:00:00.000Z');
+		expect(forthAndBackAsJson('2020-12-31T00:00:00.000Z')).toBe('2020-12-31T00:00:00.000Z');
+		expect(forthAndBackAsJson('1921-01-01T00:00:00.000Z')).toBe('1921-01-01T00:00:00.000Z');
+		expect(forthAndBackAsJson('1999-12-31T00:00:00.000Z')).toBe('1999-12-31T00:00:00.000Z');
+		expect(forthAndBackAsJson('2000-01-01T06:30:00.000Z')).toBe('2000-01-01T06:30:00.000Z');
+		expect(forthAndBackAsJson('2020-12-31T13:27:30.000Z')).toBe('2020-12-31T13:27:30.000Z');
+		expect(forthAndBackAsJson('1921-12-31T12:00:00.000Z')).toBe('1921-12-31T12:00:00.000Z');
+		expect(forthAndBackAsJson('1999-12-31T12:00:00.000Z')).toBe('1999-12-31T12:00:00.000Z');
+		expect(forthAndBackAsJson('2000-01-01T11:59:59.000Z')).toBe('2000-01-01T11:59:59.000Z');
+		expect(forthAndBackAsJson('1999-12-31T23:59:59.000Z')).toBe('1999-12-31T23:59:59.000Z');
+		expect(forthAndBackAsJson('2000-01-01T00:00:00.000Z')).toBe('2000-01-01T00:00:00.000Z');
+		expect(forthAndBackAsJson('2020-12-31T12:00:00.125Z')).toBe('2020-12-31T12:00:00.125Z');
+		expect(forthAndBackAsJson('1921-12-31T12:00:00.375Z')).toBe('1921-12-31T12:00:00.375Z');
+		expect(forthAndBackAsJson('1999-12-31T12:00:00.500Z')).toBe('1999-12-31T12:00:00.500Z');
+		expect(forthAndBackAsJson('2000-01-01T11:59:59.250Z')).toBe('2000-01-01T11:59:59.250Z');
+		expect(forthAndBackAsJson('1999-12-31T23:59:59.750Z')).toBe('1999-12-31T23:59:59.750Z');
+	});
+	test('arr2cardNumber works', () => {
+		expect(siProtocol.arr2cardNumber([0x00, 0x00, 0x00])).toBe(0x000000);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x00])).toBe(0x003412);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x01])).toBe(0x003412 + 1 * 100000);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x02])).toBe(0x003412 + 2 * 100000);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x03])).toBe(0x003412 + 3 * 100000);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x04])).toBe(0x003412 + 4 * 100000);
+		// the following should actually never appear, as 0x053412 = 341010, which would be represented differently
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x05])).toBe(0x053412);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x08])).toBe(0x083412);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x56])).toBe(0x563412);
+		expect(siProtocol.arr2cardNumber([0x00, 0x00, 0x00, 0x00])).toBe(0x00000000);
+		expect(siProtocol.arr2cardNumber([0x00, 0x00, 0x00, 0x01])).toBe(0x01000000);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x56, 0x78])).toBe(0x78563412);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, 0x56, undefined])).toBe(undefined);
+		expect(siProtocol.arr2cardNumber([0x12, 0x34, undefined, 0x78])).toBe(undefined);
+		expect(siProtocol.arr2cardNumber([0x12, undefined, 0x56, 0x78])).toBe(undefined);
+		expect(siProtocol.arr2cardNumber([undefined, 0x34, 0x56, 0x78])).toBe(undefined);
+	});
+	test('arr2cardNumber sanitizes', () => {
+		expect(() => siProtocol.arr2cardNumber([])).toThrow();
+		expect(() => siProtocol.arr2cardNumber([1])).toThrow();
+		expect(() => siProtocol.arr2cardNumber([1, 2])).toThrow();
+		expect(() => siProtocol.arr2cardNumber([1, 2, 3, 4, 5])).toThrow();
+		expect(() => siProtocol.arr2cardNumber([1, 2, 3, 4, 5, 6, 7, 8])).toThrow();
+	});
+	test('cardNumber2arr works', () => {
+		expect(siProtocol.cardNumber2arr(0x000000)).toEqual([0x00, 0x00, 0x00, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x003412)).toEqual([0x12, 0x34, 0x00, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x003412 + 1 * 100000)).toEqual([0x12, 0x34, 0x01, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x003412 + 2 * 100000)).toEqual([0x12, 0x34, 0x02, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x003412 + 3 * 100000)).toEqual([0x12, 0x34, 0x03, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x003412 + 4 * 100000)).toEqual([0x12, 0x34, 0x04, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x083412)).toEqual([0x12, 0x34, 0x08, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x563412)).toEqual([0x12, 0x34, 0x56, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x00000000)).toEqual([0x00, 0x00, 0x00, 0x00]);
+		expect(siProtocol.cardNumber2arr(0x01000000)).toEqual([0x00, 0x00, 0x00, 0x01]);
+		expect(siProtocol.cardNumber2arr(0x78563412)).toEqual([0x12, 0x34, 0x56, 0x78]);
+		expect(siProtocol.cardNumber2arr(undefined)).toEqual([undefined, undefined, undefined, undefined]);
+	});
+	test('consistent cardNumber <=> arr conversion', () => {
+		const cardNumbers = [1000, 10000, 65535, 100000, 165535, 200000, 265535, 300000, 365535, 400000, 465535, 500000, 599999, 999999, 1000000, 1999999, 2000000, 2999999];
+		cardNumbers.forEach((cardNumber) => {
+			const arr = siProtocol.cardNumber2arr(cardNumber);
+			const restoredCardNumber = siProtocol.arr2cardNumber(arr);
+			expect(restoredCardNumber).toEqual(cardNumber);
+		});
+	});
+	test('prettyMessage', () => {
+		expect(siProtocol.prettyMessage({ command: proto.cmd.GET_MS, parameters: [] }).length > 3).toBe(true);
+		expect(siProtocol.prettyMessage({ mode: proto.ACK }).length > 3).toBe(true);
+	});
+	test('CRC16', () => {
+		expect(siProtocol.CRC16([])).toEqual([0x00, 0x00]);
+		expect(siProtocol.CRC16([0x01])).toEqual([0x01, 0x00]);
+		expect(siProtocol.CRC16([0x12])).toEqual([0x12, 0x00]);
+		expect(siProtocol.CRC16([0xff])).toEqual([0xff, 0x00]);
+		expect(siProtocol.CRC16([0x01, 0x02])).toEqual([0x01, 0x02]);
+		expect(siProtocol.CRC16([0x12, 0x34])).toEqual([0x12, 0x34]);
+		expect(siProtocol.CRC16([0x12, 0x34, 0x56])).toEqual([0xba, 0xbb]);
+		expect(siProtocol.CRC16([0x12, 0x32, 0x56])).toEqual([0xba, 0xaf]);
+		expect(siProtocol.CRC16([0x12, 0x34, 0x56, 0x78])).toEqual([0x1e, 0x83]);
+		expect(siProtocol.CRC16([0x12, 0x32, 0x56, 0x78])).toEqual([0x1e, 0xfb]);
+	});
+
+	test('parse WAKEUP', () => {
+		expect(siProtocol.parse([proto.WAKEUP])).toEqual({
+			message: { mode: proto.WAKEUP },
+			remainder: []
+		});
+		const randomByte = testUtils.getRandomByte();
+		expect(siProtocol.parse([proto.WAKEUP, randomByte])).toEqual({
+			message: { mode: proto.WAKEUP },
+			remainder: [randomByte]
+		});
+	});
+	test('parse ACK', () => {
+		expect(siProtocol.parse([proto.ACK])).toEqual({
+			message: { mode: proto.ACK },
+			remainder: []
+		});
+		const randomByte = testUtils.getRandomByte();
+		expect(siProtocol.parse([proto.ACK, randomByte])).toEqual({
+			message: { mode: proto.ACK },
+			remainder: [randomByte]
+		});
+	});
+	test('parse NAK', () => {
+		expect(siProtocol.parse([proto.NAK])).toEqual({
+			message: { mode: proto.NAK },
+			remainder: []
+		});
+		const randomByte = testUtils.getRandomByte();
+		expect(siProtocol.parse([proto.NAK, randomByte])).toEqual({
+			message: { mode: proto.NAK },
+			remainder: [randomByte]
+		});
+	});
+	test('parse with invalid start byte', () => {
+		const invalidStartByte = testUtils.getRandomByteExcept([proto.STX, proto.WAKEUP, proto.NAK]);
+		console.debug(`Chosen invalid start byte: ${utils.prettyHex([invalidStartByte])}`);
+		expect(siProtocol.parse([invalidStartByte])).toEqual({ message: null, remainder: [] });
+		const randomByte = testUtils.getRandomByte();
+		expect(siProtocol.parse([invalidStartByte, randomByte])).toEqual({
+			message: null,
+			remainder: [randomByte]
+		});
+	});
+
+	test('parse command without remainder', () => {
+		const parseForMessage = (message: siProtocol.SiMessage) => siProtocol.parse(siProtocol.render(message)).message;
+		expect(parseForMessage({ command: 0x00, parameters: [] })).toEqual({
+			command: 0x00,
+			parameters: []
+		});
+		expect(parseForMessage({ command: 0xff, parameters: [0xee] })).toEqual({
+			command: 0xff,
+			parameters: [0xee]
+		});
+	});
+	test('parse command with remainder', () => {
+		const parseForMessageWithRemainder = (message: siProtocol.SiMessage) => siProtocol.parse([...siProtocol.render(message), 0xdd]);
+		expect(parseForMessageWithRemainder({ command: 0x00, parameters: [] })).toEqual({
+			message: { command: 0x00, parameters: [] },
+			remainder: [0xdd]
+		});
+		expect(parseForMessageWithRemainder({ command: 0xff, parameters: [0xee] })).toEqual({
+			message: { command: 0xff, parameters: [0xee] },
+			remainder: [0xdd]
+		});
+	});
+	test('parse incomplete but valid command', () => {
+		getValidButIncompleteMessageBytes().forEach((cutOffCommand) => {
+			expect(siProtocol.parse(cutOffCommand)).toEqual({ message: null, remainder: cutOffCommand });
+		});
+	});
+	test('parse command with invalid ETX', () => {
+		const invalidETX = testUtils.getRandomByteExcept([proto.ETX]);
+		console.debug(`Chosen invalid ETX: ${utils.prettyHex([invalidETX])}`);
+		expect(siProtocol.parse([proto.STX, 0x00, 0x00, 0x00, 0x00, invalidETX])).toEqual({
+			message: null,
+			remainder: [0x00, 0x00, 0x00, 0x00, invalidETX]
+		});
+		expect(siProtocol.parse([proto.STX, 0xff, 0x01, 0xee, 0x00, 0x01, invalidETX])).toEqual({
+			message: null,
+			remainder: [0xff, 0x01, 0xee, 0x00, 0x01, invalidETX]
+		});
+		expect(siProtocol.parse([proto.STX, 0x00, 0x00, 0x00, 0x01, invalidETX, 0xdd])).toEqual({
+			message: null,
+			remainder: [0x00, 0x00, 0x00, 0x01, invalidETX, 0xdd]
+		});
+		expect(siProtocol.parse([proto.STX, 0xff, 0x01, 0xee, 0x00, 0x01, invalidETX, 0xdd])).toEqual({
+			message: null,
+			remainder: [0xff, 0x01, 0xee, 0x00, 0x01, invalidETX, 0xdd]
+		});
+	});
+	test('parse command with invalid CRC', () => {
+		expect(siProtocol.parse([proto.STX, 0x00, 0x00, 0x00, 0x01, proto.ETX])).toEqual({
+			message: null,
+			remainder: []
+		});
+		expect(siProtocol.parse([proto.STX, 0xff, 0x01, 0xee, 0x00, 0x01, proto.ETX])).toEqual({
+			message: null,
+			remainder: []
+		});
+		expect(siProtocol.parse([proto.STX, 0x00, 0x00, 0x00, 0x01, proto.ETX, 0xdd])).toEqual({
+			message: null,
+			remainder: [0xdd]
+		});
+		expect(siProtocol.parse([proto.STX, 0xff, 0x01, 0xee, 0x00, 0x01, proto.ETX, 0xdd])).toEqual({
+			message: null,
+			remainder: [0xdd]
+		});
+	});
+
+	test('parseAll without remainder', () => {
+		const stream0 = [] as number[];
+		expect(siProtocol.parseAll(stream0)).toEqual({
+			messages: [],
+			remainder: []
+		});
+
+		const stream1 = siProtocol.render({ command: 0x00, parameters: [] });
+		expect(siProtocol.parseAll(stream1)).toEqual({
+			messages: [{ command: 0x00, parameters: [] }],
+			remainder: []
+		});
+
+		const stream2 = [...siProtocol.render({ command: 0x00, parameters: [] }), proto.WAKEUP, ...siProtocol.render({ command: 0xff, parameters: [0xee] })];
+		expect(siProtocol.parseAll(stream2)).toEqual({
+			messages: [{ command: 0x00, parameters: [] }, { mode: proto.WAKEUP }, { command: 0xff, parameters: [0xee] }],
+			remainder: []
+		});
+	});
+	test('parseAll with valid remainder', () => {
+		getValidButIncompleteMessageBytes().forEach((cutOffCommand) => {
+			const stream0 = [...cutOffCommand];
+			expect(siProtocol.parseAll(stream0)).toEqual({
+				messages: [],
+				remainder: cutOffCommand
+			});
+
+			const stream1 = [...siProtocol.render({ command: 0x00, parameters: [] }), proto.NAK, ...cutOffCommand];
+			expect(siProtocol.parseAll(stream1)).toEqual({
+				messages: [{ command: 0x00, parameters: [] }, { mode: proto.NAK }],
+				remainder: cutOffCommand
+			});
+
+			const stream2 = [proto.WAKEUP, ...siProtocol.render({ command: 0x00, parameters: [] }), ...siProtocol.render({ command: 0xff, parameters: [0xee] }), ...cutOffCommand];
+			expect(siProtocol.parseAll(stream2)).toEqual({
+				messages: [{ mode: proto.WAKEUP }, { command: 0x00, parameters: [] }, { command: 0xff, parameters: [0xee] }],
+				remainder: cutOffCommand
+			});
+		});
+	});
+
+	test('render ACK', () => {
+		expect(siProtocol.render({ mode: proto.ACK })).toEqual([proto.ACK]);
+	});
+	test('render NAK', () => {
+		expect(siProtocol.render({ mode: proto.NAK })).toEqual([proto.NAK]);
+	});
+	test('render WAKEUP', () => {
+		expect(siProtocol.render({ mode: proto.WAKEUP })).toEqual([proto.WAKEUP]);
+	});
+	test('render command', () => {
+		expect(siProtocol.render({ command: 0x00, parameters: [] })).toEqual([proto.STX, 0x00, 0x00, 0x00, 0x00, proto.ETX]);
+		expect(siProtocol.render({ command: 0xff, parameters: [0xee] })).toEqual([proto.STX, 0xff, 0x01, 0xee, 0xec, 0x0a, proto.ETX]);
+		expect(siProtocol.render({ mode: undefined, command: 0x00, parameters: [] })).toEqual([proto.STX, 0x00, 0x00, 0x00, 0x00, proto.ETX]);
+		expect(siProtocol.render({ mode: undefined, command: 0xff, parameters: [0xee] })).toEqual([proto.STX, 0xff, 0x01, 0xee, 0xec, 0x0a, proto.ETX]);
+	});
+	test('render invalid mode', () => {
+		const invalidMode = testUtils.getRandomByteExcept([proto.WAKEUP, proto.NAK, proto.ACK]);
+		expect(() => siProtocol.render({ mode: invalidMode })).toThrow();
+	});
+
+	test('SiDate SiStorage integration', () => {
+		const weirdStorage = storage.defineStorage(0x09, {
+			weirdDate: new siProtocol.SiDate(3, (i) => i),
+			crazyDate: new siProtocol.SiDate(6, (i) => 0x03 + i)
+		});
+
+		const myWeirdStorage = weirdStorage(utils.unPrettyHex('0F 03 07 00 00 00 00 00 00'));
+
+		expect(myWeirdStorage.get('weirdDate')!.value).toEqual(new Date(2015, 2, 7));
+		myWeirdStorage.set('weirdDate', new Date(2017, 12, 30));
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('12 01 1E 00 00 00 00 00 00'));
+		expect(myWeirdStorage.get('weirdDate')!.value).toEqual(new Date(2017, 12, 30));
+
+		expect(myWeirdStorage.get('crazyDate')).toEqual(undefined);
+		myWeirdStorage.set('crazyDate', new Date(2003, 1, 30, 3, 7, 5));
+		expect(myWeirdStorage.data.toJS()).toEqual(utils.unPrettyHex('12 01 1E 03 03 02 00 2B D9'));
+		expect(myWeirdStorage.get('crazyDate')!.value).toEqual(new Date(2003, 1, 30, 3, 7, 5));
+
+		const unknownWeirdStorage = weirdStorage();
+		const ModifyUndefinedException = storage.ModifyUndefinedException;
+
+		expect(unknownWeirdStorage.get('weirdDate')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('weirdDate', new Date(2017, 12, 30))).toThrow(ModifyUndefinedException);
+
+		expect(unknownWeirdStorage.get('crazyDate')).toBe(undefined);
+		expect(() => unknownWeirdStorage.set('crazyDate', new Date(2003, 1, 30, 3, 7, 5))).toThrow(ModifyUndefinedException);
+	});
+
+	describe('SiDate', () => {
+		const mySiDate = new siProtocol.SiDate(3, (i) => i);
+		const fieldValueOf = (value: Date) => new storage.SiFieldValue(mySiDate, value);
+		test('typeSpecificIsValueValid', () => {
+			expect(mySiDate.typeSpecificIsValueValid(new Date())).toBe(true);
+		});
+		test('valueToString', () => {
+			expect(mySiDate.valueToString(json2date('2000-01-01T00:00:00.000Z')!)).toBe('2000-01-01T00:00:00.000Z');
+			expect(mySiDate.valueToString(json2date('2020-12-31T13:27:30.000Z')!)).toBe('2020-12-31T13:27:30.000Z');
+		});
+		test('valueFromString', () => {
+			expect(mySiDate.valueFromString('2000-01-01T00:00:00.000Z')).toEqual(json2date('2000-01-01T00:00:00.000Z')!);
+			expect(mySiDate.valueFromString('2020-12-31T13:27:30.000Z')).toEqual(json2date('2020-12-31T13:27:30.000Z')!);
+			expect(mySiDate.valueFromString('2020-12-31T13:27:30.000') instanceof storage.ValueFromStringError).toBe(true);
+			expect(mySiDate.valueFromString('2020-12-31T13:27:30Z') instanceof storage.ValueFromStringError).toBe(true);
+			expect(mySiDate.valueFromString('2020-12-31Z') instanceof storage.ValueFromStringError).toBe(true);
+			expect(mySiDate.valueFromString('2020-12-31') instanceof storage.ValueFromStringError).toBe(true);
+			expect(mySiDate.valueFromString('test') instanceof storage.ValueFromStringError).toBe(true);
+		});
+		test('extractFromData gives field value', () => {
+			const data = Immutable.List([0x00, 0x01, 0x01]);
+			const fieldValue = mySiDate.extractFromData(data);
+			expect(fieldValue instanceof storage.SiFieldValue).toBe(true);
+			expect(fieldValue!.field).toBe(mySiDate);
+			expect(fieldValue!.value).toEqual(json2date('2000-01-01T00:00:00.000Z')!);
+		});
+		test('extractFromData', () => {
+			const getExtractedFieldValue = (bytes: (number | undefined)[]) => mySiDate.extractFromData(Immutable.List(bytes));
+			expect(getExtractedFieldValue([0x00, 0x01, 0x01])!.value instanceof Date).toBe(true);
+			expect(getExtractedFieldValue([0x00, 0x01, undefined])).toBe(undefined);
+			expect(getExtractedFieldValue([0x00, undefined, 0x01])).toBe(undefined);
+			expect(getExtractedFieldValue([undefined, 0x00, 0x01])).toBe(undefined);
+			expect(getExtractedFieldValue([0x00])).toBe(undefined);
+			expect(getExtractedFieldValue([])).toBe(undefined);
+		});
+		test('updateData', () => {
+			const initialData = Immutable.List([0x00, 0x00, 0x00]);
+			const updateInitialData = (newValue: Date | storage.SiFieldValue<Date>) => mySiDate.updateData(initialData, newValue).toJS();
+
+			expect(updateInitialData(json2date('2000-01-01T00:00:00.000Z')!)).toEqual([0x00, 0x01, 0x01]);
+			expect(updateInitialData(fieldValueOf(json2date('2000-01-01T00:00:00.000Z')!))).toEqual([0x00, 0x01, 0x01]);
+		});
+		test('updateData modify undefined', () => {
+			const updateData = (data: (number | undefined)[], newValue: Date | storage.SiFieldValue<Date>) => mySiDate.updateData(Immutable.List(data), newValue).toJS();
+
+			expect(() => updateData([], json2date('2000-01-01T00:00:00.000Z')!)).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([], fieldValueOf(json2date('2000-01-01T00:00:00.000Z')!))).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([0x00, 0x00, undefined], json2date('2000-01-01T00:00:00.000Z')!)).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([0x00, undefined, 0x00], json2date('2000-01-01T00:00:00.000Z')!)).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([undefined, 0x00, 0x00], json2date('2000-01-01T00:00:00.000Z')!)).toThrow(storage.ModifyUndefinedException);
+		});
+	});
+
+	describe('SiTime', () => {
+		const mySiTime = new siProtocol.SiTime([[0x01], [0x00]]);
+		const myInexistentSiTime = new siProtocol.SiTime(undefined);
+		const fieldValueOf = (value: siProtocol.SiTimestamp) => new storage.SiFieldValue(mySiTime, value);
+		test('typeSpecificIsValueValid', () => {
+			expect(mySiTime.typeSpecificIsValueValid({time:0})).toBe(true);
+			expect(mySiTime.typeSpecificIsValueValid({time:43199})).toBe(true);
+			expect(mySiTime.typeSpecificIsValueValid({time:86400})).toBe(false);
+			expect(mySiTime.typeSpecificIsValueValid(null)).toBe(true);
+		});
+		test('valueToString', () => {
+			expect(mySiTime.valueToString({time:0})).toBe('00:00:00');
+			expect(mySiTime.valueToString({time:43199})).toBe('11:59:59');
+			expect(mySiTime.valueToString(null)).toBe('NO_TIME');
+		});
+		test('valueFromString', () => {
+			expect(mySiTime.valueFromString('00:00:00')).toEqual({time:0});
+			expect(mySiTime.valueFromString('11:59:59')).toEqual({time:43199});
+			expect(mySiTime.valueFromString('NO_TIME')).toBe(null);
+			expect(mySiTime.valueFromString('06:12') instanceof storage.ValueFromStringError).toBe(true);
+			expect(mySiTime.valueFromString('test') instanceof storage.ValueFromStringError).toBe(true);
+		});
+		test('extractFromData gives field value', () => {
+			const data = Immutable.List([0x01, 0x01]);
+			const fieldValue = mySiTime.extractFromData(data);
+			expect(fieldValue instanceof storage.SiFieldValue).toBe(true);
+			expect(fieldValue!.field).toBe(mySiTime);
+			expect(JSON.stringify(fieldValue!.value)).toBe(JSON.stringify({time:257, weekcounter: undefined, weekday: undefined}));
+		});
+		test('extractFromData', () => {
+			const getExtractedFieldValue = (bytes: (number | undefined)[]) => mySiTime.extractFromData(Immutable.List(bytes));
+			expect(JSON.stringify(getExtractedFieldValue([0x00, 0x01])!.value)).toBe(JSON.stringify({time:1, weekcounter: undefined, weekday: undefined}));
+			expect(getExtractedFieldValue([0xee, 0xee])!.value).toBe(null);
+			expect(getExtractedFieldValue([0x00, undefined])).toBe(undefined);
+			expect(getExtractedFieldValue([undefined, 0x01])).toBe(undefined);
+			expect(getExtractedFieldValue([0x00])).toBe(undefined);
+			expect(getExtractedFieldValue([])).toBe(undefined);
+		});
+		test('extractFromData for inexistent', () => {
+			const getExtractedFieldValue = (bytes: (number | undefined)[]) => myInexistentSiTime.extractFromData(Immutable.List(bytes));
+			expect(getExtractedFieldValue([0x00, 0x01])!.value).toBe(null);
+		});
+		test('updateData', () => {
+			const initialData = Immutable.List([0x00, 0x00]);
+			const updateInitialData = (newValue: siProtocol.SiTimestamp | storage.SiFieldValue<siProtocol.SiTimestamp>) => mySiTime.updateData(initialData, newValue).toJS();
+
+			expect(updateInitialData({time:257})).toEqual([0x01, 0x01]);
+			expect(updateInitialData(fieldValueOf({time:257}))).toEqual([0x01, 0x01]);
+			expect(updateInitialData(null)).toEqual([0xee, 0xee]);
+			expect(updateInitialData(fieldValueOf(null))).toEqual([0xee, 0xee]);
+		});
+		test('updateData for inexistent', () => {
+			const initialData = Immutable.List([0x00, 0x00]);
+			const updateInitialData = (newValue: siProtocol.SiTimestamp | storage.SiFieldValue<siProtocol.SiTimestamp>) => myInexistentSiTime.updateData(initialData, newValue).toJS();
+
+			expect(updateInitialData({time:257})).toEqual([0x00, 0x00]);
+			expect(updateInitialData(fieldValueOf({time:257}))).toEqual([0x00, 0x00]);
+		});
+		test('updateData modify undefined', () => {
+			const updateData = (data: (number | undefined)[], newValue: siProtocol.SiTimestamp | storage.SiFieldValue<siProtocol.SiTimestamp>) => mySiTime.updateData(Immutable.List(data), newValue).toJS();
+
+			expect(() => updateData([], {time:257})).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([], fieldValueOf({time:257}))).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([0x00, undefined], {time:257})).toThrow(storage.ModifyUndefinedException);
+			expect(() => updateData([undefined, 0x01], {time:257})).toThrow(storage.ModifyUndefinedException);
+		});
+	});
+});