sportident.js 1.0.0 → 1.0.1

package/src/SiStation/SiMainStation.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import _ from 'lodash';
-import { proto } from '../constants';
-import type * as siProtocol from '../siProtocol';
-import * as testUtils from '../testUtils';
-import type { ISiCard } from '../SiCard/ISiCard';
-import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
-import type { ISiDeviceDriver } from '../SiDevice/ISiDeviceDriver';
-import { SiDevice } from '../SiDevice/SiDevice';
-import { SiMainStationSiCardInsertedEvent, SiMainStationSiCardObservedEvent, SiMainStationSiCardRemovedEvent } from './ISiMainStation';
-import { type ISiTargetMultiplexer, SiTargetMultiplexerMessageEvent, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
-import { SiTargetMultiplexer } from './SiTargetMultiplexer';
-import { siStationStorageDefinition } from './BaseSiStation';
-import { getBSM8Station } from './siStationExamples';
-import { SiMainStation } from './SiMainStation';
-import { getSiCard5Examples } from '../SiCard/types/siCard5Examples';
-import { getSiCard6Examples } from '../SiCard/types/siCard6Examples';
-import { FakeSiCard5 } from '../fakes/FakeSiCard/types/FakeSiCard5';
-import { FakeSiCard6 } from '../fakes/FakeSiCard/types/FakeSiCard6';
-
-testUtils.useFakeTimers();
-
-function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
-	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
-}
-
-describe('SiMainStation', () => {
-	test('fromSiDevice', () => {
-		const fakeSiDevice = new SiDevice('fromSiDevice', {
-			driver: mockDriver({ name: 'FakeSiDevice' })
-		});
-		const myMainStation1 = SiMainStation.fromSiDevice(fakeSiDevice);
-		expect(myMainStation1 instanceof SiMainStation).toBe(true);
-		expect(myMainStation1.ident).toBe('Direct-FakeSiDevice-fromSiDevice');
-		expect(myMainStation1.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
-		const myMainStation2 = SiMainStation.fromSiDevice(fakeSiDevice);
-		expect(myMainStation2).toBe(myMainStation1);
-		expect(myMainStation2.ident).toBe('Direct-FakeSiDevice-fromSiDevice');
-		expect(myMainStation2.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
-	});
-	test('fromSiTargetMultiplexer', () => {
-		const myTargetMultiplexer = new SiTargetMultiplexer({ ident: 'fake-ident' } as ISiDevice<ISiDeviceDriverData<unknown>>);
-		const myMainStation1 = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
-		expect(myMainStation1 instanceof SiMainStation).toBe(true);
-		expect(myMainStation1.ident).toBe('Direct-fake-ident');
-		expect(myMainStation1.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
-		const myMainStation2 = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
-		expect(myMainStation2).toBe(myMainStation1);
-		expect(myMainStation2.ident).toBe('Direct-fake-ident');
-		expect(myMainStation2.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
-	});
-
-	test('can readCards', async () => {
-		const storage = siStationStorageDefinition(getBSM8Station().storageData);
-		storage.set('mode', 'Control');
-		storage.set('code', 31);
-		storage.set('autoSend', true);
-		storage.set('handshake', false);
-		storage.set('beeps', false);
-		storage.set('flashes', false);
-		const fakeSiTargetMultiplexer = {
-			addEventListener: () => undefined,
-			sendMessage: (_target: SiTargetMultiplexerTarget, message: siProtocol.SiMessage, _numResponses: number) => {
-				if (message.mode !== undefined) {
-					throw new Error();
-				}
-				if (message.command === proto.cmd.GET_SYS_VAL) {
-					return Promise.resolve([[0x00, 0x00, 0x00, ...storage.data]]);
-				}
-				if (message.command === proto.cmd.SET_SYS_VAL) {
-					storage.splice(message.parameters[0], message.parameters.length - 1, ...message.parameters.slice(1));
-					return Promise.resolve([[0x00, 0x00, message.parameters[0]]]);
-				}
-				throw new Error();
-			}
-		} as unknown as ISiTargetMultiplexer;
-		const mySiStation = new SiMainStation(fakeSiTargetMultiplexer);
-		const cardsRead: ISiCard[] = [];
-		const cleanUpFunction = await mySiStation.readCards((card) => {
-			cardsRead.push(card);
-		});
-		await testUtils.nTimesAsync(3, () => testUtils.advanceTimersByTime(0));
-		if (cleanUpFunction === undefined) {
-			throw new Error('expect cleanUp function');
-		}
-		expect(storage.get('mode')!.value).toBe('Readout');
-		expect(storage.get('code')!.value).toBe(10);
-		expect(storage.get('autoSend')!.value).toBe(false);
-		expect(storage.get('handshake')!.value).toBe(true);
-		expect(storage.get('beeps')!.value).toBe(true);
-		expect(storage.get('flashes')!.value).toBe(true);
-
-		const fakeSiCard = {
-			cardNumber: 1234
-		} as ISiCard;
-		mySiStation.dispatchEvent('siCardInserted', new SiMainStationSiCardInsertedEvent(mySiStation, fakeSiCard));
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
-		expect(cardsRead).toEqual([{ cardNumber: 1234 } as ISiCard]);
-
-		const actualCleanUpFunction: () => Promise<void> = cleanUpFunction;
-		await actualCleanUpFunction();
-		expect(storage.get('mode')!.value).toBe('Control');
-		expect(storage.get('code')!.value).toBe(31);
-		expect(storage.get('autoSend')!.value).toBe(true);
-		expect(storage.get('handshake')!.value).toBe(false);
-		expect(storage.get('beeps')!.value).toBe(false);
-		expect(storage.get('flashes')!.value).toBe(false);
-
-		mySiStation.dispatchEvent('siCardInserted', new SiMainStationSiCardInsertedEvent(mySiStation, fakeSiCard));
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
-		// No additional entry
-		expect(cardsRead).toEqual([{ cardNumber: 1234 } as ISiCard]);
-	});
-
-	test('card detection & removal', async () => {
-		const myTargetMultiplexer = new SiTargetMultiplexer({} as ISiDevice<ISiDeviceDriverData<unknown>>);
-		const myMainStation = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
-		const testData = getSiCard5Examples().fullCard;
-		const myFakeSiCard5 = new FakeSiCard5(testData.storageData);
-
-		const insertedCardNumbers: number[] = [];
-		const handleCardInserted = (e: SiMainStationSiCardInsertedEvent) => {
-			insertedCardNumbers.push(e.siCard.cardNumber);
-		};
-		myMainStation.addEventListener('siCardInserted', handleCardInserted);
-		const message = myFakeSiCard5.handleDetect() as siProtocol.SiMessageWithoutMode;
-		myTargetMultiplexer.dispatchEvent(
-			'message',
-			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
-				command: message.command,
-				parameters: [...[0x00, 0x00], ...message.parameters] as number[]
-			})
-		);
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(insertedCardNumbers).toEqual([406402]);
-
-		const removedCardNumbers: number[] = [];
-		const handleCardRemoved = (e: SiMainStationSiCardRemovedEvent) => {
-			removedCardNumbers.push(e.siCard.cardNumber);
-		};
-		myMainStation.addEventListener('siCardRemoved', handleCardRemoved);
-		myTargetMultiplexer.dispatchEvent(
-			'message',
-			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
-				command: proto.cmd.SI_REM,
-				parameters: [...[0x00, 0x00], ...message.parameters] as number[]
-			})
-		);
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(removedCardNumbers).toEqual([406402]);
-
-		myTargetMultiplexer.dispatchEvent(
-			'message',
-			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
-				command: proto.cmd.SI_REM,
-				parameters: [0x00, 0x00, 0x01, 0x23, 0x45, 0x67]
-			})
-		);
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(removedCardNumbers).toEqual([406402]);
-
-		myMainStation.removeEventListener('siCardInserted', handleCardInserted);
-		myMainStation.removeEventListener('siCardRemoved', handleCardRemoved);
-	});
-	test('card observation', async () => {
-		const myTargetMultiplexer = new SiTargetMultiplexer({} as ISiDevice<ISiDeviceDriverData<unknown>>);
-		const myMainStation = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
-		const testData = getSiCard6Examples().fullCard;
-		const myFakeSiCard6 = new FakeSiCard6(testData.storageData);
-		const observedCardNumbers: number[] = [];
-		const handleCardObserved = (e: SiMainStationSiCardObservedEvent) => {
-			observedCardNumbers.push(e.siCard.cardNumber);
-		};
-		myMainStation.addEventListener('siCardObserved', handleCardObserved);
-		const message = myFakeSiCard6.handleDetect() as siProtocol.SiMessageWithoutMode;
-		myTargetMultiplexer.dispatchEvent(
-			'message',
-			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
-				command: proto.cmd.TRANS_REC,
-				parameters: [...[0x00, 0x00], ...message.parameters] as number[]
-			})
-		);
-
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(observedCardNumbers).toEqual([testData.cardData.cardNumber]);
-	});
-	test('card observation with mode', async () => {
-		const myTargetMultiplexer = new SiTargetMultiplexer({} as ISiDevice<ISiDeviceDriverData<unknown>>);
-		const myMainStation = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
-		const observedCardNumbers: number[] = [];
-		const handleCardObserved = (e: SiMainStationSiCardObservedEvent) => {
-			observedCardNumbers.push(e.siCard.cardNumber);
-		};
-		myMainStation.addEventListener('siCardObserved', handleCardObserved);
-		myTargetMultiplexer.dispatchEvent('message', new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, { mode: proto.NAK }));
-
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(observedCardNumbers).toEqual([]);
-	});
-	test('other message', () => {
-		const fakeSiTargetMultiplexer = {
-			addEventListener: () => undefined,
-			sendMessage: () => Promise.resolve([])
-		} as unknown as ISiTargetMultiplexer;
-		const mySiStation = new SiMainStation(fakeSiTargetMultiplexer);
-		mySiStation.handleMessage({ command: proto.cmd.SIGNAL, parameters: [0x01] });
-	});
-
-	test('sendMessage', async () => {
-		const fakeSiTargetMultiplexer = {
-			addEventListener: () => undefined,
-			sendMessage: () => Promise.resolve([])
-		} as unknown as ISiTargetMultiplexer;
-		const mySiStation = new SiMainStation(fakeSiTargetMultiplexer);
-		let sendMessageSucceeded:boolean|undefined = undefined;
-		mySiStation.sendMessage({} as siProtocol.SiMessage).then(() => {
-			sendMessageSucceeded = true;
-		});
-		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
-		expect(sendMessageSucceeded).toBe(true);
-	});
-});

package/src/SiStation/SiMainStation.ts

@@ -1,133 +0,0 @@
-import * as utils from '../utils';
-import * as siProtocol from '../siProtocol';
-import { proto } from '../constants';
-import { BaseSiCard } from '../SiCard';
-import type { ISiCard } from '../SiCard/ISiCard';
-import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
-import type { ISiStation } from './ISiStation';
-import { type SiMainStationEvents, SiMainStationSiCardInsertedEvent, SiMainStationSiCardObservedEvent, SiMainStationSiCardRemovedEvent } from './ISiMainStation';
-import { type ISiTargetMultiplexer, SiTargetMultiplexerMessageEvent, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
-import { BaseSiStation, type ISiStationStorageFields } from './BaseSiStation';
-import { SiTargetMultiplexer } from './SiTargetMultiplexer';
-
-type SiStationSetup = {
-	[key in keyof ISiStationStorageFields]?: ISiStationStorageFields[key];
-};
-
-type CleanUpFunction = () => Promise<void>;
-
-export class SiMainStation extends BaseSiStation<SiTargetMultiplexerTarget.Direct> implements ISiStation<SiTargetMultiplexerTarget.Direct> {
-	static fromSiDevice(siDevice: ISiDevice<ISiDeviceDriverData<unknown>>): SiMainStation {
-		const multiplexer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		return this.fromSiTargetMultiplexer(multiplexer);
-	}
-
-	static fromSiTargetMultiplexer(multiplexer: ISiTargetMultiplexer): SiMainStation {
-		return this.fromSiTargetMultiplexerWithGivenTarget(multiplexer, SiTargetMultiplexerTarget.Direct, () => new this(multiplexer, SiTargetMultiplexerTarget.Direct)) as SiMainStation;
-	}
-
-	public siCard: ISiCard | null = null;
-
-	constructor(siTargetMultiplexer: ISiTargetMultiplexer, multiplexerTarget: SiTargetMultiplexerTarget.Direct = SiTargetMultiplexerTarget.Direct) {
-		super(siTargetMultiplexer, multiplexerTarget);
-		siTargetMultiplexer.addEventListener(
-			'message', // not directMessage, as the target might still be unknown, but we still need the message
-			(e: SiTargetMultiplexerMessageEvent) => {
-				const message = e.message;
-				this.handleMessage(message);
-				console.log(`There's a SiMainStation listening to this ${message}`);
-			}
-		);
-	}
-
-	readCards(onCardInserted: (card: ISiCard) => void, siStationSetupModification: SiStationSetup = {}): Promise<CleanUpFunction> {
-		const siStationSetup: SiStationSetup = {
-			code: 10,
-			mode: 'Readout',
-			autoSend: false,
-			handshake: true,
-			beeps: true,
-			flashes: true,
-			...siStationSetupModification
-		};
-		const siStationSetupKeys = Object.keys(siStationSetup) as (keyof ISiStationStorageFields)[];
-		const oldState: SiStationSetup = {};
-
-		const handleCardInserted = (e: SiMainStationSiCardInsertedEvent) => {
-			onCardInserted(e.siCard);
-		};
-
-		const cleanUp: CleanUpFunction = () => {
-			this.removeEventListener('siCardInserted', handleCardInserted);
-			return this.atomically(() => {
-				siStationSetupKeys.forEach((infoName) => {
-					const oldInfoValue = oldState[infoName];
-					if (oldInfoValue !== undefined) {
-						this.setInfo(infoName, oldInfoValue);
-					}
-				});
-			});
-		};
-
-		return this.atomically(() => {
-			siStationSetupKeys.forEach((infoName: keyof ISiStationStorageFields) => {
-				const oldFieldValue = this.getInfo(infoName);
-				// @ts-ignore
-				oldState[infoName] = oldFieldValue ? oldFieldValue.value : undefined;
-				const newValue = siStationSetup[infoName];
-				if (newValue !== undefined) {
-					this.setInfo(infoName, newValue);
-				}
-			});
-		}).then(() => {
-			this.addEventListener('siCardInserted', handleCardInserted);
-			return cleanUp;
-		});
-	}
-
-	handleMessage(message: siProtocol.SiMessage): void {
-		if (message.mode !== undefined) {
-			return;
-		}
-		const { command, parameters } = message;
-		const detectedSiCard = BaseSiCard.detectFromMessage(message);
-		if (detectedSiCard !== undefined) {
-			detectedSiCard.mainStation = this;
-			this.siCard = detectedSiCard as ISiCard;
-			this.dispatchEvent('siCardInserted', new SiMainStationSiCardInsertedEvent(this, detectedSiCard as ISiCard));
-			return;
-		}
-		const handleSiCardRemoved = () => {
-			const removedCardNumber = siProtocol.arr2cardNumber([parameters[5], parameters[4], parameters[3]]); // TODO: also [2]?
-			if (this.siCard !== null && this.siCard.cardNumber === removedCardNumber) {
-				this.dispatchEvent('siCardRemoved', new SiMainStationSiCardRemovedEvent(this, this.siCard));
-			} else {
-				console.warn(`Card ${removedCardNumber} was removed, but never inserted`);
-			}
-			this.siCard = null;
-		};
-		const handleSiCardObserved = () => {
-			const observedCardNumber = siProtocol.arr2cardNumber([parameters[5], parameters[4], parameters[3]]); // TODO: also [2]?
-			if (observedCardNumber === undefined) {
-				return;
-			}
-			const transRecordCard = BaseSiCard.fromCardNumber(observedCardNumber);
-			if (transRecordCard !== undefined) {
-				transRecordCard.mainStation = this;
-				this.dispatchEvent('siCardObserved', new SiMainStationSiCardObservedEvent(this, transRecordCard as ISiCard));
-			}
-		};
-		const handlerByCommand: { [command: number]: () => void } = {
-			[proto.cmd.SI_REM]: handleSiCardRemoved,
-			[proto.cmd.TRANS_REC]: handleSiCardObserved
-		};
-		const handler = handlerByCommand[command];
-		if (handler === undefined) {
-			return;
-		}
-		handler();
-	}
-}
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface SiMainStation extends utils.EventTarget<SiMainStationEvents> {}
-utils.applyMixins(SiMainStation, [utils.EventTarget]);

package/src/SiStation/SiSendTask.ts

@@ -1,50 +0,0 @@
-import * as siProtocol from '../siProtocol';
-import { SiSendTaskState } from './ISiSendTask';
-
-export class SiSendTask {
-	public state: SiSendTaskState = SiSendTaskState.Queued;
-	public responses: number[][] = [];
-	private timeoutTimer: unknown;
-
-	constructor(
-		public message: siProtocol.SiMessage,
-		public numResponses: number,
-		public timeoutInMiliseconds: number,
-		public onResolve: (task: SiSendTask) => void,
-		public onReject: (task: SiSendTask) => void
-	) {
-		this.timeoutTimer = setTimeout(() => {
-			const shouldAbortInState: { [state in SiSendTaskState]: boolean } = {
-				[SiSendTaskState.Queued]: true,
-				[SiSendTaskState.Sending]: true,
-				[SiSendTaskState.Sent]: true,
-				[SiSendTaskState.Succeeded]: false,
-				[SiSendTaskState.Failed]: false
-			};
-			if (!shouldAbortInState[this.state]) {
-				return;
-			}
-			console.debug(`Timeout: ${siProtocol.prettyMessage(this.message)} (expected ${this.numResponses} responses)`, this.responses);
-			this.fail();
-		}, timeoutInMiliseconds);
-	}
-
-	addResponse(response: number[]): void {
-		this.responses.push(response);
-		if (this.responses.length === this.numResponses) {
-			this.succeed();
-		}
-	}
-
-	succeed(): void {
-		this.state = SiSendTaskState.Succeeded;
-		clearTimeout(this.timeoutTimer as Parameters<typeof clearTimeout>[0]);
-		this.onResolve(this);
-	}
-
-	fail(): void {
-		this.state = SiSendTaskState.Failed;
-		clearTimeout(this.timeoutTimer as Parameters<typeof clearTimeout>[0]);
-		this.onReject(this);
-	}
-}

package/src/SiStation/SiTargetMultiplexer.targeting.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { proto } from '../constants';
-import * as siProtocol from '../siProtocol';
-import * as testUtils from '../testUtils';
-import { SiDevice } from '../SiDevice/SiDevice';
-import { SiDeviceState, SiDeviceReceiveEvent, type ISiDeviceDriverData } from '../SiDevice/ISiDevice';
-import type { ISiDeviceDriver } from '../SiDevice/ISiDeviceDriver';
-import { SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
-import { SiTargetMultiplexer } from './SiTargetMultiplexer';
-
-testUtils.useFakeTimers();
-
-function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
-	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
-}
-
-describe('SiTargetMultiplexer', () => {
-	test('handles targeting', async () => {
-		const siDevice = new SiDevice('handlesTargeting0', {
-			driver: mockDriver({
-				send: () => Promise.resolve()
-			})
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
-
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = {
-			sendingFinished: false,
-			resendingFinished: false,
-			remoteSendingFinished: false
-		};
-		muxer.sendMessage(SiTargetMultiplexerTarget.Direct, randomMessage, 0, 1).then((responses) => {
-			expect(responses.length).toBe(0);
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.sendingFinished = true;
-		});
-		setTimeout(() => {
-			siDevice.dispatchEvent(
-				'receive',
-				new SiDeviceReceiveEvent(
-					siDevice,
-					siProtocol.render({
-						command: proto.cmd.SET_MS,
-						parameters: [0x00, 0x00, proto.P_MS_DIRECT]
-					})
-				)
-			);
-		}, 1);
-		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Unknown);
-		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Direct);
-		await testUtils.advanceTimersByTime(0); // resolve setTarget send promise
-		await testUtils.advanceTimersByTime(1); // trigger setTarget receive
-		await testUtils.nTimesAsync(10, () => testUtils.advanceTimersByTime(1));
-		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Direct);
-		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Direct);
-		await testUtils.advanceTimersByTime(0);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({
-			sendingFinished: true,
-			resendingFinished: false,
-			remoteSendingFinished: false
-		});
-
-		muxer.sendMessage(SiTargetMultiplexerTarget.Direct, randomMessage, 0, 1).then((responses) => {
-			expect(responses.length).toBe(0);
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.resendingFinished = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		await testUtils.advanceTimersByTime(0);
-		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Direct);
-		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Direct);
-		expect(timeState).toEqual({
-			sendingFinished: true,
-			resendingFinished: true,
-			remoteSendingFinished: false
-		});
-
-		muxer.sendMessage(SiTargetMultiplexerTarget.Remote, randomMessage, 0, 1).then((responses) => {
-			expect(responses.length).toBe(0);
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.remoteSendingFinished = true;
-		});
-		setTimeout(() => {
-			siDevice.dispatchEvent(
-				'receive',
-				new SiDeviceReceiveEvent(
-					siDevice,
-					siProtocol.render({
-						command: proto.cmd.SET_MS,
-						parameters: [0x00, 0x00, proto.P_MS_REMOTE]
-					})
-				)
-			);
-		}, 1);
-		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Direct);
-		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Remote);
-		await testUtils.advanceTimersByTime(0); // resolve setTarget send promise
-		await testUtils.advanceTimersByTime(1); // trigger setTarget receive
-		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Remote);
-		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Remote);
-		await testUtils.advanceTimersByTime(0);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({
-			sendingFinished: true,
-			resendingFinished: true,
-			remoteSendingFinished: true
-		});
-	});
-});