sportident.js 1.0.0 → 1.0.2

package/src/SiStation/SiTargetMultiplexer.test.ts

@@ -1,605 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { proto } from '../constants';
-import * as siProtocol from '../siProtocol';
-import * as testUtils from '../testUtils';
-import { SiDeviceState, SiDeviceReceiveEvent, type ISiDeviceDriverData } from '../SiDevice/ISiDevice';
-import type { ISiDeviceDriver } from '../SiDevice/ISiDeviceDriver';
-import { SiDevice } from '../SiDevice/SiDevice';
-import { SiTargetMultiplexerDirectMessageEvent, SiTargetMultiplexerMessageEvent, SiTargetMultiplexerRemoteMessageEvent, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
-import { SiSendTaskState } from './ISiSendTask';
-import { DIRECT_DEVICE_INITIATED_COMMANDS, SiTargetMultiplexer } from './SiTargetMultiplexer';
-
-testUtils.useFakeTimers();
-
-function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
-	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
-}
-
-describe('SiTargetMultiplexer', () => {
-	test('is unique per device', () => {
-		const siDevice = new SiDevice('isUniquePerDevice', {
-			driver: mockDriver({ name: 'FakeSiDevice' })
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer1 = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer1 instanceof SiTargetMultiplexer).toBe(true);
-		const muxer2 = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer2).toBe(muxer1);
-	});
-
-	test('handles receiving', () => {
-		const siDevice = new SiDevice('handlesReceiving', {
-			driver: mockDriver({})
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
-
-		const receivedMessages: siProtocol.SiMessage[] = [];
-		const recordMessage = (e: SiTargetMultiplexerMessageEvent) => {
-			receivedMessages.push(e.message);
-		};
-		muxer.addEventListener('message', recordMessage);
-
-		const receivedDirectMessages: siProtocol.SiMessage[] = [];
-		const recordDirectMessage = (e: SiTargetMultiplexerDirectMessageEvent) => {
-			receivedDirectMessages.push(e.message);
-		};
-		muxer.addEventListener('directMessage', recordDirectMessage);
-
-		const receivedRemoteMessages: siProtocol.SiMessage[] = [];
-		const recordRemoteMessage = (e: SiTargetMultiplexerRemoteMessageEvent) => {
-			receivedRemoteMessages.push(e.message);
-		};
-		muxer.addEventListener('remoteMessage', recordRemoteMessage);
-
-		const directOnlyCommands = Object.keys(DIRECT_DEVICE_INITIATED_COMMANDS).map(Number);
-		const randomMessage1 = testUtils.getRandomMessage({
-			command: testUtils.getRandomByteExcept(directOnlyCommands)
-		});
-		siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage1)));
-		expect(receivedMessages).toEqual([randomMessage1]);
-		expect(receivedDirectMessages).toEqual([]);
-		expect(receivedRemoteMessages).toEqual([]);
-
-		const randomMessage2 = testUtils.getRandomMessage({
-			command: testUtils.getRandomByteExcept(directOnlyCommands)
-		});
-		muxer.target = SiTargetMultiplexerTarget.Direct;
-		siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage2)));
-		expect(receivedMessages).toEqual([randomMessage1, randomMessage2]);
-		expect(receivedDirectMessages).toEqual([randomMessage2]);
-		expect(receivedRemoteMessages).toEqual([]);
-
-		const randomMessage3 = testUtils.getRandomMessage({
-			command: testUtils.getRandomByteExcept(directOnlyCommands)
-		});
-		muxer.target = SiTargetMultiplexerTarget.Remote;
-		siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage3)));
-		expect(receivedMessages).toEqual([randomMessage1, randomMessage2, randomMessage3]);
-		expect(receivedDirectMessages).toEqual([randomMessage2]);
-		expect(receivedRemoteMessages).toEqual([randomMessage3]);
-
-		muxer.removeEventListener('message', recordMessage);
-		muxer.removeEventListener('directMessage', recordDirectMessage);
-		muxer.removeEventListener('remoteMessage', recordRemoteMessage);
-	});
-
-	test('handles simple sending', async () => {
-		const siDevice = new SiDevice('handlesSending0', {
-			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 };
-		muxer.sendMessageToLatestTarget(randomMessage, 0, 1).then((responses) => {
-			expect(responses.length).toBe(0);
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.sendingFinished = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ sendingFinished: true });
-	});
-
-	test('handles sending and waiting for 1 response', async () => {
-		const siDevice = new SiDevice('handlesSending1', {
-			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 };
-		muxer.sendMessageToLatestTarget(randomMessage, 1, 2).then((responses) => {
-			expect(responses.length).toBe(1);
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.sendingFinished = true;
-		});
-		setTimeout(() => {
-			siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ sendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ sendingFinished: true });
-	});
-
-	test('handles sending and waiting for 1 NAK', async () => {
-		const siDevice = new SiDevice('handlesSending1NAK', {
-			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 = { sendingFailed: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 1, 2).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.sendingFailed = true;
-		});
-		setTimeout(() => {
-			siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render({ mode: proto.NAK })));
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ sendingFailed: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ sendingFailed: true });
-	});
-
-	test('handles sending and waiting for 2 responses', async () => {
-		const siDevice = new SiDevice('handlesSending2', {
-			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 = { receive1: false, receive2: false, sendingFinished: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 2, 3).then((responses) => {
-			expect(responses.length).toBe(2);
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.sendingFinished = true;
-		});
-		setTimeout(() => {
-			siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
-			timeState.receive1 = true;
-		}, 1);
-		setTimeout(() => {
-			siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
-			timeState.receive2 = true;
-		}, 2);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ receive1: false, receive2: false, sendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ receive1: true, receive2: false, sendingFinished: false });
-		await testUtils.nTimesAsync(10, () => testUtils.advanceTimersByTime(1));
-		expect(timeState).toEqual({ receive1: true, receive2: true, sendingFinished: true });
-	});
-
-	test('handles sending and timing out waiting for 1 response', async () => {
-		const siDevice = new SiDevice('handlesSending1Timeout', {
-			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 = { timedOut: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 1, 1).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.timedOut = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ timedOut: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ timedOut: true });
-	});
-
-	test('handles sending and timing out waiting for 2 responses', async () => {
-		const siDevice = new SiDevice('handlesSending2Timeout', {
-			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 = { receive1: false, timedOut: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 2, 2).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.timedOut = true;
-		});
-		setTimeout(() => {
-			siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
-			timeState.receive1 = true;
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ receive1: false, timedOut: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ receive1: true, timedOut: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ receive1: true, timedOut: true });
-	});
-
-	test('does not time out, if it already succeeded', async () => {
-		const siDevice = new SiDevice('noTimeoutIfSucceeded', {
-			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 timeoutInMiliseconds = 2;
-		const timeState = {
-			madeSuccessful: false,
-			timeoutPassed: false,
-			timedOut: false,
-			succeeded: false
-		};
-		muxer
-			.sendMessageToLatestTarget(randomMessage, 1, timeoutInMiliseconds)
-			.then(() => {
-				timeState.succeeded = true;
-			})
-			.catch(() => {
-				timeState.timedOut = true;
-			});
-		setTimeout(() => {
-			muxer._test.sendQueue[0].state = SiSendTaskState.Succeeded;
-			timeState.madeSuccessful = true;
-		}, 1);
-		setTimeout(() => {
-			timeState.timeoutPassed = true;
-		}, timeoutInMiliseconds);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({
-			madeSuccessful: false,
-			timeoutPassed: false,
-			timedOut: false,
-			succeeded: false
-		});
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({
-			madeSuccessful: true,
-			timeoutPassed: false,
-			timedOut: false,
-			succeeded: false
-		});
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({
-			madeSuccessful: true,
-			timeoutPassed: true,
-			timedOut: false,
-			succeeded: false
-		});
-	});
-
-	test('does not succeed, if response for different command arrives', async () => {
-		const siDevice = new SiDevice('differentCommand', {
-			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 = { receive1: false, timedOut: false, succeeded: false };
-		muxer
-			.sendMessageToLatestTarget(randomMessage, 1, 2)
-			.then(() => {
-				timeState.succeeded = true;
-			})
-			.catch(() => {
-				expect(muxer._test.sendQueue.length).toBe(0);
-				timeState.timedOut = true;
-			});
-		setTimeout(() => {
-			siDevice.dispatchEvent(
-				'receive',
-				new SiDeviceReceiveEvent(
-					siDevice,
-					siProtocol.render({
-						command: testUtils.getRandomByteExcept([randomMessage.command]),
-						parameters: randomMessage.parameters
-					})
-				)
-			);
-			timeState.receive1 = true;
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ receive1: false, timedOut: false, succeeded: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ receive1: true, timedOut: false, succeeded: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ receive1: true, timedOut: true, succeeded: false });
-	});
-
-	test('cannot send to unopened SiDevice', async () => {
-		const siDevice = new SiDevice('cannotSendToUnopened', {
-			driver: mockDriver({})
-		});
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
-
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { timedOut: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 1, 1).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.timedOut = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ timedOut: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ timedOut: true });
-	});
-
-	test('handles sending as soon as device is openend', async () => {
-		const siDevice = new SiDevice('handlesSendingAsSoonAsOpened', {
-			driver: mockDriver({
-				send: () => Promise.resolve()
-			})
-		});
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
-
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { deviceOpened: false, sendingFinished: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 0, 3).then(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.sendingFinished = true;
-		});
-		setTimeout(() => {
-			siDevice.setState(SiDeviceState.Opened);
-			timeState.deviceOpened = true;
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ deviceOpened: false, sendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ deviceOpened: true, sendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ deviceOpened: true, sendingFinished: true });
-	});
-
-	test('sends all as soon as device is openend', async () => {
-		const siDevice = new SiDevice('sendsAllAsSoonAsOpened', {
-			driver: mockDriver({
-				send: () => Promise.resolve()
-			})
-		});
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
-
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { deviceOpened: false, numSuccess: 0, allSendingFinished: false };
-		const getMuxerPromise = () =>
-			muxer.sendMessageToLatestTarget(randomMessage, 0, 4).then(() => {
-				timeState.numSuccess = (timeState.numSuccess || 0) + 1;
-			});
-		Promise.all([getMuxerPromise(), getMuxerPromise()]).then(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.allSendingFinished = true;
-		});
-		setTimeout(() => {
-			siDevice.setState(SiDeviceState.Opened);
-			timeState.deviceOpened = true;
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ deviceOpened: false, numSuccess: 0, allSendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ deviceOpened: true, numSuccess: 0, allSendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ deviceOpened: true, numSuccess: 1, allSendingFinished: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ deviceOpened: true, numSuccess: 2, allSendingFinished: false });
-		await testUtils.advanceTimersByTime(0); // for Promise.all
-		expect(timeState).toEqual({ deviceOpened: true, numSuccess: 2, allSendingFinished: true });
-	});
-
-	test('aborts sending as soon as device is closed', async () => {
-		const siDevice = new SiDevice('abortsAllAsSoonAsClosed', {
-			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 = {
-			numSuccess: 0,
-			numAbort: 0,
-			deviceClosed: false,
-			allSendingFinished: false
-		};
-		const getMuxerPromise = () =>
-			muxer
-				.sendMessageToLatestTarget(randomMessage, 0, 4)
-				.then(
-					() => {
-						timeState.numSuccess = (timeState.numSuccess || 0) + 1;
-					},
-					() => {}
-				)
-				.then(
-					() => {
-						timeState.numAbort = (timeState.numAbort || 0) + 1;
-					},
-					() => {}
-				);
-		Promise.all([getMuxerPromise(), getMuxerPromise(), getMuxerPromise()]).then(
-			() => {
-				expect(muxer._test.sendQueue.length).toBe(0);
-				timeState.allSendingFinished = true;
-			},
-			() => {}
-		);
-		setTimeout(() => {
-			siDevice.setState(SiDeviceState.Closing);
-			timeState.deviceClosed = true;
-		}, 1);
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({
-			numSuccess: 1,
-			numAbort: 0,
-			deviceClosed: false,
-			allSendingFinished: false
-		});
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({
-			numSuccess: 1,
-			numAbort: 2,
-			deviceClosed: true,
-			allSendingFinished: false
-		});
-		await testUtils.advanceTimersByTime(0); // for Promise.all (not called)
-		expect(timeState).toEqual({
-			numSuccess: 1,
-			numAbort: 2,
-			deviceClosed: true,
-			allSendingFinished: false
-		});
-	});
-
-	test('handles device failing to send', async () => {
-		const siDevice = new SiDevice('handlesDeviceFailingToSend', {
-			driver: mockDriver({
-				send: () => Promise.reject(new Error('test'))
-			})
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
-
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { timedOut: false };
-		muxer.sendMessageToLatestTarget(randomMessage, 1, 1).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.timedOut = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ timedOut: false });
-		await testUtils.advanceTimersByTime(1);
-		expect(timeState).toEqual({ timedOut: true });
-	});
-
-	test('cannot send to unknown target', async () => {
-		const siDevice = new SiDevice('undefinedTarget', { driver: mockDriver({}) });
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { setToUnknownFailed: false };
-		muxer.sendMessage(SiTargetMultiplexerTarget.Unknown, randomMessage, 1, 1).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.setToUnknownFailed = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ setToUnknownFailed: true });
-	});
-	test('cannot send to switching target', async () => {
-		const siDevice = new SiDevice('switchingTarget', { driver: mockDriver({}) });
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { setToSwitchingFailed: false };
-		muxer.sendMessage(SiTargetMultiplexerTarget.Switching, randomMessage, 1, 1).catch(() => {
-			expect(muxer._test.sendQueue.length).toBe(0);
-			timeState.setToSwitchingFailed = true;
-		});
-		await testUtils.advanceTimersByTime(0);
-		expect(timeState).toEqual({ setToSwitchingFailed: true });
-	});
-	test('handles error switching target', async () => {
-		const siDevice = new SiDevice('errorSwitchingTarget', {
-			driver: mockDriver({
-				send: () => Promise.reject(new Error('test'))
-			})
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { setTargetFailed: false };
-		muxer.sendMessage(SiTargetMultiplexerTarget.Remote, randomMessage, 1, 1).catch(() => {
-			timeState.setTargetFailed = true;
-		});
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(muxer.target).toEqual(SiTargetMultiplexerTarget.Unknown);
-		expect(timeState).toEqual({ setTargetFailed: true });
-	});
-	test('handles unclear target switch response', async () => {
-		const siDevice = new SiDevice('errorSwitchingTarget', {
-			driver: mockDriver({
-				send: () => {
-					setTimeout(() => {
-						siDevice.dispatchEvent(
-							'receive',
-							new SiDeviceReceiveEvent(
-								siDevice,
-								siProtocol.render({
-									command: proto.cmd.SET_MS,
-									parameters: [SiTargetMultiplexerTarget.Direct]
-								})
-							)
-						);
-					}, 0);
-					return Promise.resolve();
-				}
-			})
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
-		const randomMessage = testUtils.getRandomMessage({});
-		const timeState = { setTargetFailed: false };
-		muxer.sendMessage(SiTargetMultiplexerTarget.Remote, randomMessage, 1, 1).catch(() => {
-			timeState.setTargetFailed = true;
-		});
-		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-		expect(muxer.target).toEqual(SiTargetMultiplexerTarget.Unknown);
-		expect(timeState).toEqual({ setTargetFailed: true });
-	});
-	test('handles direct device-initiated command', async () => {
-		const siDevice = new SiDevice('errorSwitchingTarget', {
-			driver: mockDriver({
-				send: () => Promise.reject(new Error('test'))
-			})
-		});
-		siDevice.setState(SiDeviceState.Opened);
-		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-		const deviceInitiatedMessage = siProtocol.render({
-			command: proto.cmd.SI5_DET,
-			parameters: [0x00, 0x0a, 0x00, 0x04, 0x19, 0x02]
-		});
-		siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, deviceInitiatedMessage));
-		await testUtils.nTimesAsync(10, () => testUtils.advanceTimersByTime(1));
-		expect(muxer.target).toEqual(SiTargetMultiplexerTarget.Direct);
-		expect(muxer.latestTarget).toEqual(SiTargetMultiplexerTarget.Direct);
-	});
-});