sportident.js 1.0.0 → 1.0.2

package/src/SiCard/raceResultTools.test.ts

@@ -1,260 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import type { IRaceResultData } from './IRaceResultData';
-import { getOrderedRaceResult, getRaceResultFromOrdered, type IOrderedRaceResult, makeStartZeroTime, monotonizeOrderedRaceResult, monotonizeRaceResult, prettyRaceResult } from './raceResultTools';
-
-const EMPTY_RACE_RESULT: IRaceResultData = {};
-const EMPTY_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	orderedTimes: []
-};
-
-const UNKNOWN_PUNCH_TIME_RACE_RESULT: IRaceResultData = {
-	punches: [{ code: 31, time: null }]
-};
-const UNKNOWN_PUNCH_TIME_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	orderedTimes: [],
-	punches: [{ code: 31, timeIndex: null }]
-};
-
-const WITHOUT_PUNCHES_RACE_RESULT: IRaceResultData = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	clearTime: {time:1},
-	checkTime: {time:2},
-	startTime: {time:3},
-	finishTime: {time:6}
-};
-const WITHOUT_PUNCHES_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	orderedTimes: [{time:1}, {time:2}, {time:3}, {time:6}],
-	clearTimeIndex: 0,
-	checkTimeIndex: 1,
-	startTimeIndex: 2,
-	finishTimeIndex: 3
-};
-
-const COMPLETE_RACE_RESULT: IRaceResultData = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	clearTime: {time:1},
-	checkTime: {time:2},
-	startTime: {time:3},
-	finishTime: {time:6},
-	punches: [
-		{ code: 31, time: {time:4} },
-		{ code: 32, time: {time:5} }
-	]
-};
-const COMPLETE_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	orderedTimes: [{time:1}, {time:2}, {time:3}, {time:4}, {time:5}, {time:6}],
-	clearTimeIndex: 0,
-	checkTimeIndex: 1,
-	startTimeIndex: 2,
-	punches: [
-		{ code: 31, timeIndex: 3 },
-		{ code: 32, timeIndex: 4 }
-	],
-	finishTimeIndex: 5
-};
-
-const UNKNOWN_TIMES_RACE_RESULT: IRaceResultData = {
-	checkTime: {time:2},
-	startTime: {time:3},
-	finishTime: {time:6},
-	punches: [
-		{ code: 31, time: null },
-		{ code: 32, time: {time:5} }
-	]
-};
-const UNKNOWN_TIMES_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	orderedTimes: [{time:2}, {time:3}, {time:5}, {time:6}],
-	checkTimeIndex: 0,
-	startTimeIndex: 1,
-	punches: [
-		{ code: 31, timeIndex: null },
-		{ code: 32, timeIndex: 2 }
-	],
-	finishTimeIndex: 3
-};
-
-const IMMONOTONE_RACE_RESULT: IRaceResultData = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	clearTime: {time:1},
-	checkTime: {time:2},
-	startTime: {time:1},
-	finishTime: {time:2},
-	punches: [
-		{ code: 31, time: {time:2} },
-		{ code: 32, time: {time:1} }
-	]
-};
-const MONOTONE_RACE_RESULT: IRaceResultData = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	clearTime: {time:1},
-	checkTime: {time:2},
-	startTime: {time:43201},
-	finishTime: {time:86402},
-	punches: [
-		{ code: 31, time: {time:43202} },
-		{ code: 32, time: {time:86401} }
-	]
-};
-
-const IMMONOTONE_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	orderedTimes: [{time:1}, {time:2}, {time:1}, {time:2}, {time:1}, {time:2}],
-	clearTimeIndex: 0,
-	checkTimeIndex: 1,
-	startTimeIndex: 2,
-	punches: [
-		{ code: 31, timeIndex: 3 },
-		{ code: 32, timeIndex: 4 }
-	],
-	finishTimeIndex: 5
-};
-const MONOTONE_ORDERED_RACE_RESULT: IOrderedRaceResult = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	orderedTimes: [{time:1}, {time:2}, {time:43201}, {time:43202}, {time:86401}, {time:86402}],
-	clearTimeIndex: 0,
-	checkTimeIndex: 1,
-	startTimeIndex: 2,
-	punches: [
-		{ code: 31, timeIndex: 3 },
-		{ code: 32, timeIndex: 4 }
-	],
-	finishTimeIndex: 5
-};
-
-const COMPLETE_START_ZEROED_RACE_RESULT: IRaceResultData = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	clearTime: {time:-2},
-	checkTime: {time:-1},
-	startTime: {time:0},
-	finishTime: {time:3},
-	punches: [
-		{ code: 31, time: {time:1} },
-		{ code: 32, time: {time:2} }
-	]
-};
-
-const UNKNOWN_TIMES_START_ZEROED_RACE_RESULT: IRaceResultData = {
-	checkTime: {time:-1},
-	startTime: {time:0},
-	finishTime: {time:3},
-	punches: [
-		{ code: 31, time: null },
-		{ code: 32, time: {time:2} }
-	]
-};
-
-const WITHOUT_PUNCHES_START_ZEROED_RACE_RESULT: IRaceResultData = {
-	cardNumber: 1234,
-	cardHolder: { firstName: 'John' },
-	clearTime: {time:-2},
-	checkTime: {time:-1},
-	startTime: {time:0},
-	finishTime: {time:3}
-};
-
-describe('raceResultTools', () => {
-	describe('prettyRaceResult', () => {
-		test('works for empty race result', async () => {
-			const emptyRaceResult: IRaceResultData = {};
-			expect(prettyRaceResult(emptyRaceResult)).toEqual('Card Number: ?\nClear: ?\nCheck: ?\nStart: ?\nFinish: ?\n? Punches\nCard Holder:\n?\n');
-		});
-		test('works for race result with zero punches', async () => {
-			const zeroPunchesRaceResult: IRaceResultData = {
-				punches: []
-			};
-			expect(prettyRaceResult(zeroPunchesRaceResult)).toEqual('Card Number: ?\nClear: ?\nCheck: ?\nStart: ?\nFinish: ?\nNo Punches\nCard Holder:\n?\n');
-		});
-		test('works for race result with empty card holder', async () => {
-			const emptyCardHolderRaceResult: IRaceResultData = {
-				cardHolder: {}
-			};
-			expect(prettyRaceResult(emptyCardHolderRaceResult)).toEqual('Card Number: ?\nClear: ?\nCheck: ?\nStart: ?\nFinish: ?\n? Punches\nCard Holder:\nEmpty Card Holder\n');
-		});
-		test('works for complete race result', async () => {
-			const completeRaceResult: IRaceResultData = {
-				cardNumber: 123,
-				cardHolder: { firstName: 'John' },
-				clearTime: {time:1},
-				checkTime: {time:2},
-				startTime: {time:3},
-				finishTime: {time:5},
-				punches: [{ code: 31, time: {time:4} }]
-			};
-			expect(prettyRaceResult(completeRaceResult)).toEqual('Card Number: 123\nClear: 1\nCheck: 2\nStart: 3\nFinish: 5\n31: 4\nCard Holder:\nfirstName: John\n');
-		});
-	});
-
-	describe('getOrderedRaceResult', () => {
-		test('works for empty race result', async () => {
-			expect(getOrderedRaceResult(EMPTY_RACE_RESULT)).toEqual(EMPTY_ORDERED_RACE_RESULT);
-		});
-		test('works for race result with punches of unknown time', async () => {
-			expect(getOrderedRaceResult(UNKNOWN_PUNCH_TIME_RACE_RESULT)).toEqual(UNKNOWN_PUNCH_TIME_ORDERED_RACE_RESULT);
-		});
-		test('works for complete race result', async () => {
-			expect(getOrderedRaceResult(COMPLETE_RACE_RESULT)).toEqual(COMPLETE_ORDERED_RACE_RESULT);
-		});
-		test('works for race result without punches', async () => {
-			expect(getOrderedRaceResult(WITHOUT_PUNCHES_RACE_RESULT)).toEqual(WITHOUT_PUNCHES_ORDERED_RACE_RESULT);
-		});
-		test('works for race result without clearTime and startTime', async () => {
-			expect(getOrderedRaceResult(UNKNOWN_TIMES_RACE_RESULT)).toEqual(UNKNOWN_TIMES_ORDERED_RACE_RESULT);
-		});
-	});
-
-	describe('getRaceResultFromOrdered', () => {
-		test('works for empty race result', async () => {
-			expect(getRaceResultFromOrdered(EMPTY_ORDERED_RACE_RESULT)).toEqual(EMPTY_RACE_RESULT);
-		});
-		test('works for race result with punches of unknown time', async () => {
-			expect(getRaceResultFromOrdered(UNKNOWN_PUNCH_TIME_ORDERED_RACE_RESULT)).toEqual(UNKNOWN_PUNCH_TIME_RACE_RESULT);
-		});
-		test('works for complete race result', async () => {
-			expect(getRaceResultFromOrdered(COMPLETE_ORDERED_RACE_RESULT)).toEqual(COMPLETE_RACE_RESULT);
-		});
-		test('works for race result without punches', async () => {
-			expect(getRaceResultFromOrdered(WITHOUT_PUNCHES_ORDERED_RACE_RESULT)).toEqual(WITHOUT_PUNCHES_RACE_RESULT);
-		});
-		test('works for race result without clearTime and punch[0]', async () => {
-			expect(getRaceResultFromOrdered(UNKNOWN_TIMES_ORDERED_RACE_RESULT)).toEqual(UNKNOWN_TIMES_RACE_RESULT);
-		});
-	});
-
-	describe('monotonizeOrderedRaceResult', () => {
-		test('works for ordered race result', async () => {
-			expect(monotonizeOrderedRaceResult(IMMONOTONE_ORDERED_RACE_RESULT)).toEqual(MONOTONE_ORDERED_RACE_RESULT);
-		});
-	});
-
-	describe('monotonizeRaceResult', () => {
-		test('works for race result', async () => {
-			expect(monotonizeRaceResult(IMMONOTONE_RACE_RESULT)).toEqual(MONOTONE_RACE_RESULT);
-		});
-	});
-
-	describe('makeStartZeroTime', () => {
-		test('works for complete race result', async () => {
-			expect(makeStartZeroTime(COMPLETE_RACE_RESULT)).toEqual(COMPLETE_START_ZEROED_RACE_RESULT);
-		});
-		test('works for race result with unknown times', async () => {
-			expect(makeStartZeroTime(UNKNOWN_TIMES_RACE_RESULT)).toEqual(UNKNOWN_TIMES_START_ZEROED_RACE_RESULT);
-		});
-		test('works for race result without punches', async () => {
-			expect(makeStartZeroTime(WITHOUT_PUNCHES_RACE_RESULT)).toEqual(WITHOUT_PUNCHES_START_ZEROED_RACE_RESULT);
-		});
-		test('fails for race result without start time', async () => {
-			expect(() => makeStartZeroTime(EMPTY_RACE_RESULT)).toThrow();
-		});
-	});
-});

package/src/SiCard/raceResultTools.ts

@@ -1,150 +0,0 @@
-import * as siProtocol from '../siProtocol';
-import type { IRaceResultData, IPunch } from './IRaceResultData';
-
-export interface IOrderedRaceResult {
-	cardNumber?: number;
-	cardHolder?: { [property: string]: unknown };
-	orderedTimes: siProtocol.SiTimestamp[];
-	clearTimeIndex?: number | null;
-	checkTimeIndex?: number | null;
-	startTimeIndex?: number | null;
-	punches?: IOrderedPunch[];
-	finishTimeIndex?: number | null;
-}
-
-export interface IOrderedPunch {
-	code: number;
-	timeIndex: number | null;
-}
-
-export const prettyRaceResult = (result: IRaceResultData): string => {
-	const punchesString = result.punches ? (result.punches.length > 0 ? result.punches.map((punch) => `${punch.code}: ${punch.time?.time??"?"}`).join('\n') : 'No Punches') : '? Punches';
-	const cardHolderString = result.cardHolder
-		? Object.keys(result.cardHolder).length > 0
-			? Object.keys(result.cardHolder)
-					.map((key) => `${key}: ${result.cardHolder![key]}`)
-					.join('\n')
-			: 'Empty Card Holder'
-		: '?';
-	return (
-		`Card Number: ${result.cardNumber !== undefined ? result.cardNumber : '?'}\n` +
-		`Clear: ${result.clearTime !== undefined ? result.clearTime?.time : '?'}\n` +
-		`Check: ${result.checkTime !== undefined ? result.checkTime?.time : '?'}\n` +
-		`Start: ${result.startTime !== undefined ? result.startTime?.time : '?'}\n` +
-		`Finish: ${result.finishTime !== undefined ? result.finishTime?.time : '?'}\n` +
-		`${punchesString}\n` +
-		'Card Holder:\n' +
-		`${cardHolderString}\n`
-	);
-};
-
-export const getOrderedRaceResult = (result: IRaceResultData): IOrderedRaceResult => {
-	const orderedResult: IOrderedRaceResult = {
-		cardNumber: result.cardNumber,
-		cardHolder: result.cardHolder,
-		orderedTimes: []
-	};
-	if (result.clearTime !== undefined && result.clearTime !== null) {
-		orderedResult.clearTimeIndex = orderedResult.orderedTimes.length;
-		orderedResult.orderedTimes.push(result.clearTime);
-	}
-	if (result.checkTime !== undefined && result.checkTime !== null) {
-		orderedResult.checkTimeIndex = orderedResult.orderedTimes.length;
-		orderedResult.orderedTimes.push(result.checkTime);
-	}
-	if (result.startTime !== undefined && result.startTime !== null) {
-		orderedResult.startTimeIndex = orderedResult.orderedTimes.length;
-		orderedResult.orderedTimes.push(result.startTime);
-	}
-	if (result.punches !== undefined) {
-		const newPunches: IOrderedPunch[] = [];
-		result.punches.forEach((punch: IPunch) => {
-			if (punch.time !== null) {
-				newPunches.push({
-					code: punch.code,
-					timeIndex: orderedResult.orderedTimes.length
-				});
-				orderedResult.orderedTimes.push(punch.time);
-			} else {
-				newPunches.push({
-					code: punch.code,
-					timeIndex: null
-				});
-			}
-		});
-		orderedResult.punches = newPunches;
-	}
-	if (result.finishTime !== undefined && result.finishTime !== null) {
-		orderedResult.finishTimeIndex = orderedResult.orderedTimes.length;
-		orderedResult.orderedTimes.push(result.finishTime);
-	}
-	return orderedResult;
-};
-
-export const getRaceResultFromOrdered = (orderedResult: IOrderedRaceResult): IRaceResultData => {
-	const getOrderedTimeIndexIfSet = (index: number | null) => (index === null ? null : orderedResult.orderedTimes[index]);
-	const getOrderedTimeIndexIfSetAndDefined = (index: number | null | undefined) => (index === undefined || index === null ? index : orderedResult.orderedTimes[index]);
-	return {
-		cardNumber: orderedResult.cardNumber,
-		cardHolder: orderedResult.cardHolder,
-		clearTime: getOrderedTimeIndexIfSetAndDefined(orderedResult.clearTimeIndex),
-		checkTime: getOrderedTimeIndexIfSetAndDefined(orderedResult.checkTimeIndex),
-		startTime: getOrderedTimeIndexIfSetAndDefined(orderedResult.startTimeIndex),
-		finishTime: getOrderedTimeIndexIfSetAndDefined(orderedResult.finishTimeIndex),
-		punches:
-			orderedResult.punches === undefined
-				? undefined
-				: orderedResult.punches.map((punch: IOrderedPunch) => ({
-						code: punch.code,
-						time: getOrderedTimeIndexIfSet(punch.timeIndex)
-				  }))
-	};
-};
-
-export const monotonizeOrderedRaceResult = (orderedData: IOrderedRaceResult): IOrderedRaceResult => {
-	let currentCarry = 0;
-	let lastTime = 0;
-	const newOrderedTimes = orderedData.orderedTimes.map((ts: siProtocol.SiTimestamp) => {
-		if(ts != null){
-			if (ts.time < lastTime) {
-				currentCarry += siProtocol.SI_TIME_CUTOFF;
-			}
-			lastTime = ts.time;
-			ts.time += currentCarry
-		}
-		return ts;
-	});
-	return {
-		...orderedData,
-		orderedTimes: newOrderedTimes
-	};
-};
-
-export const monotonizeRaceResult = (result: IRaceResultData): IRaceResultData => {
-	const orderedResult = getOrderedRaceResult(result);
-	const monotonizedOrderedResult = monotonizeOrderedRaceResult(orderedResult);
-	return getRaceResultFromOrdered(monotonizedOrderedResult);
-};
-
-export const makeStartZeroTime = (result: IRaceResultData): IRaceResultData => {
-	const zeroTime = result.startTime;
-	if (zeroTime === undefined || zeroTime === null) {
-		throw new Error('start time must be known');
-	}
-	const deductZeroTimeIfSet = (time: siProtocol.SiTimestamp) => (time === null ? null : {...time, time: (time.time - zeroTime.time)});
-	const deductZeroTimeIfSetAndDefined = (time: siProtocol.SiTimestamp | undefined) => (time === null || time === undefined ? time : {...time, time: (time.time - zeroTime.time)});
-	return {
-		...result,
-		clearTime: deductZeroTimeIfSetAndDefined(result.clearTime),
-		checkTime: deductZeroTimeIfSetAndDefined(result.checkTime),
-		startTime: deductZeroTimeIfSetAndDefined(result.startTime),
-		finishTime: deductZeroTimeIfSetAndDefined(result.finishTime),
-		punches:
-			result.punches === undefined
-				? undefined
-				: result.punches.map((punch: IPunch) => ({
-						...punch,
-						time: deductZeroTimeIfSet(punch.time)
-				  }))
-	};
-};

package/src/SiCard/types/FCard.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { BaseSiCard } from '../BaseSiCard';
-import { FCard } from './FCard';
-
-describe('FCard', () => {
-	test('is registered', () => {
-		expect(BaseSiCard.getTypeByCardNumber(13999999)).not.toEqual(FCard);
-		expect(BaseSiCard.getTypeByCardNumber(14000000)).toEqual(FCard);
-		expect(BaseSiCard.getTypeByCardNumber(14999999)).toEqual(FCard);
-		expect(BaseSiCard.getTypeByCardNumber(15000000)).not.toEqual(FCard);
-	});
-	test('is not implemented', (done) => {
-		const fCard = new FCard(14000000);
-		fCard.read().then(
-			() => done(new Error('expect reject')),
-			() => done()
-		);
-	});
-});

package/src/SiCard/types/FCard.ts

@@ -1,14 +0,0 @@
-import * as utils from '../../utils';
-import type * as siProtocol from '../../siProtocol';
-import { BaseSiCard } from '../BaseSiCard';
-
-export class FCard extends BaseSiCard {
-	static typeSpecificInstanceFromMessage(_message: siProtocol.SiMessage): FCard | undefined {
-		return undefined;
-	}
-
-	typeSpecificRead(): Promise<void> {
-		return Promise.reject(new utils.NotImplementedError());
-	}
-}
-BaseSiCard.registerNumberRange(14000000, 15000000, FCard);

package/src/SiCard/types/ModernSiCard.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import _ from 'lodash';
-import * as utils from '../../utils';
-import type * as siProtocol from '../../siProtocol';
-import { cropPunches, getCroppedString, getPunchOffset, ModernSiCard, ModernSiCardSeries, parseCardHolder, parseCardHolderString } from './ModernSiCard';
-import { getModernSiCardExamples } from './modernSiCardExamples';
-import { FakeModernSiCard } from '../../fakes/FakeSiCard/types/FakeModernSiCard';
-
-describe('ModernSiCard', () => {
-	test('exists', () => {
-		expect(ModernSiCard).not.toBe(undefined);
-
-		const myModernSiCard = new ModernSiCard(0);
-		expect(myModernSiCard.storage.data.has(0)).toBe(true);
-		expect(myModernSiCard.storage.data.get(0)).toBe(undefined);
-		expect(myModernSiCard.storage.data.has(1023)).toBe(true);
-		expect(myModernSiCard.storage.data.get(1023)).toBe(undefined);
-		expect(myModernSiCard.storage.data.has(1024)).toBe(false);
-		expect(myModernSiCard.storage.data.get(1024)).toBe(undefined);
-	});
-	test('getPunchOffset', () => {
-		expect(getPunchOffset(0)).toEqual(0x200);
-		expect(getPunchOffset(1)).toEqual(0x204);
-		expect(getPunchOffset(64)).toEqual(0x300);
-		expect(getPunchOffset(127)).toEqual(0x3fc);
-	});
-	test('cropPunches', () => {
-		expect(cropPunches([])).toEqual([]);
-		expect(cropPunches([{ code: 31, time: {time:1} }])).toEqual([{ code: 31, time: {time:1} }]);
-		expect(cropPunches([{ code: 32, time: null }])).toEqual([]);
-		expect(cropPunches([{ code: undefined, time: undefined }])).toEqual([]);
-		expect(cropPunches([{ code: 33, time: undefined }])).toEqual([]);
-		expect(
-			cropPunches([
-				{ code: 31, time: {time:1} },
-				{ code: 32, time: {time:2} },
-				{ code: 33, time: {time:3} },
-				{ code: 0xee, time: null },
-				{ code: undefined, time: undefined }
-			])
-		).toEqual([
-			{ code: 31, time: {time:1} },
-			{ code: 32, time: {time:2} },
-			{ code: 33, time: {time:3} }
-		]);
-	});
-	const cardHolderCharCodes1 = utils.unPrettyHex(`
-        4A 6F 68 6E 3B 44 6F 65 3B 6D 3B 31 39 39 30 30
-        31 33 31 3B 45 78 61 6D 70 6C 65 63 6C 75 62 3B
-        6A 6F 68 6E 2E 64 6F 65 40 67 6D 61 69 6C 2E 63
-        6F 6D 3B 2B 30 31 32 33 34 35 36 37 38 39 3B 45
-        78 61 6D 70 6C 65 74 6F 6E 3B 53 61 6D 70 6C 65
-        20 41 6C 6C 65 79 20 31 32 33 3B 31 32 33 34 3B
-        45 58 50 3B EE EE EE EE EE EE EE EE EE EE EE EE
-        EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE
-    `);
-	const cardHolderString1 = 'John;Doe;m;19900131;Exampleclub;john.doe@gmail.com;' + '+0123456789;Exampleton;Sample Alley 123;1234;EXP;';
-	const emptyCardHolderDict = {
-		firstName: undefined,
-		lastName: undefined,
-		gender: undefined,
-		birthday: undefined,
-		club: undefined,
-		email: undefined,
-		phone: undefined,
-		city: undefined,
-		street: undefined,
-		zip: undefined,
-		country: undefined,
-		isComplete: false
-	};
-	const cardHolderDict1 = {
-		firstName: 'John',
-		lastName: 'Doe',
-		gender: 'm',
-		birthday: '19900131',
-		club: 'Exampleclub',
-		email: 'john.doe@gmail.com',
-		phone: '+0123456789',
-		city: 'Exampleton',
-		street: 'Sample Alley 123',
-		zip: '1234',
-		country: 'EXP',
-		isComplete: true
-	};
-	test('getCroppedString', () => {
-		expect(getCroppedString([])).toEqual('');
-		expect(getCroppedString([0x61])).toEqual('a');
-		expect(getCroppedString([0xee])).toEqual('');
-		expect(getCroppedString([0x41, 0xee])).toEqual('A');
-		expect(getCroppedString(cardHolderCharCodes1)).toEqual(cardHolderString1);
-	});
-	test('parseCardHolderString', () => {
-		expect(parseCardHolderString('')).toEqual(emptyCardHolderDict);
-		expect(parseCardHolderString('A')).toEqual(emptyCardHolderDict);
-		expect(parseCardHolderString('A;')).toEqual({ ...emptyCardHolderDict, firstName: 'A' });
-		expect(parseCardHolderString('A;B')).toEqual({ ...emptyCardHolderDict, firstName: 'A' });
-		expect(parseCardHolderString(cardHolderString1)).toEqual(cardHolderDict1);
-	});
-	test('parseCardHolder', () => {
-		expect(parseCardHolder([])).toEqual(emptyCardHolderDict);
-		expect(parseCardHolder([0x61])).toEqual(emptyCardHolderDict);
-		expect(parseCardHolder([0x61, 0x3b])).toEqual({ ...emptyCardHolderDict, firstName: 'a' });
-		expect(parseCardHolder([0xee])).toEqual(emptyCardHolderDict);
-		expect(parseCardHolder([0x41, 0xee, 0x3b])).toEqual(emptyCardHolderDict);
-		expect(parseCardHolder([0x41, 0x3b, 0xee])).toEqual({ ...emptyCardHolderDict, firstName: 'A' });
-		expect(parseCardHolder(cardHolderCharCodes1)).toEqual(cardHolderDict1);
-	});
-	test('typeSpecificRead fails without mainStation', (done) => {
-		const myModernSiCard = new ModernSiCard(1);
-		myModernSiCard.typeSpecificRead().then(
-			() => done(new Error('expect reject')),
-			() => done()
-		);
-	});
-	const examples = getModernSiCardExamples();
-	Object.keys(examples).forEach((exampleName) => {
-		test(`typeSpecificRead works with ${exampleName} example`, (done) => {
-			const { storageData, cardData } = examples[exampleName];
-			const myModernSiCard = new ModernSiCard(cardData.cardNumber);
-			const myFakeModernSiCard = new FakeModernSiCard(storageData);
-			myModernSiCard.mainStation = {
-				sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
-					const responses: siProtocol.SiMessage[] = myFakeModernSiCard.handleRequest(message);
-					if (responses.length !== numResponses) {
-						throw new Error('Invalid numResponses');
-					}
-					return Promise.resolve(responses.map((response: siProtocol.SiMessage) => (response.mode === undefined ? [0x00, 0x00, ...response.parameters] : [])));
-				}
-			};
-
-			myModernSiCard.typeSpecificRead().then(() => {
-				expect(myModernSiCard.raceResult.cardNumber).toEqual(cardData.cardNumber);
-				expect(myModernSiCard.raceResult.startTime).toEqual(cardData.startTime);
-				expect(myModernSiCard.raceResult.finishTime).toEqual(cardData.finishTime);
-				expect(myModernSiCard.raceResult.checkTime).toEqual(cardData.checkTime);
-				expect(myModernSiCard.raceResult.punches).toEqual(cardData.punches);
-				expect(myModernSiCard.raceResult.cardHolder).toEqual(cardData.cardHolder);
-				expect(myModernSiCard.punchCount).toEqual(cardData.punchCount);
-
-				const cardSeriesString = myModernSiCard.storage.get('cardSeries')!.toString();
-				expect(cardSeriesString in ModernSiCardSeries).toBe(true);
-				done();
-			});
-		});
-	});
-	test('typeSpecificRead if typeSpecificReadCardHolder fails', (done) => {
-		const testError = new Error('test');
-		let typeSpecificReadCardHolderCalled = false;
-		class ModernSiCardWithoutCardHolder extends ModernSiCard {
-			typeSpecificGetPage() {
-				return Promise.resolve(_.range(128).map(() => 0x00));
-			}
-
-			typeSpecificReadCardHolder() {
-				typeSpecificReadCardHolderCalled = true;
-				return Promise.reject(testError);
-			}
-		}
-		const myModernSiCard = new ModernSiCardWithoutCardHolder(7123456);
-		myModernSiCard.typeSpecificRead().catch((err) => {
-			expect(typeSpecificReadCardHolderCalled).toBe(true);
-			expect(err).toBe(testError);
-			done();
-		});
-	});
-	test('typeSpecificRead if typeSpecificReadPunches fails', (done) => {
-		const testError = new Error('test');
-		let attemptedToGetPage4 = false;
-		class ModernSiCardWithoutCardHolder extends ModernSiCard {
-			typeSpecificGetPage(pageNumber: number) {
-				if (pageNumber === 4) {
-					attemptedToGetPage4 = true;
-					return Promise.reject(testError);
-				}
-				return Promise.resolve(_.range(128).map(() => 0x01));
-			}
-		}
-		const myModernSiCard = new ModernSiCardWithoutCardHolder(7123456);
-		myModernSiCard.typeSpecificRead().catch((err) => {
-			expect(attemptedToGetPage4).toBe(true);
-			expect(err).toBe(testError);
-			done();
-		});
-	});
-});