sportident.js 1.0.0

package/src/SiCard/raceResultTools.test.ts

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

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

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

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

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