sportident.js 1.3.0 → 1.3.2

package/SiStation/SiTargetMultiplexer.test.js

@@ -1,3 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,37 +41,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { describe, expect, test } from '@jest/globals';
-import { proto } from '../constants';
-import * as siProtocol from '../siProtocol';
-import * as testUtils from '../testUtils';
-import { SiDeviceState, SiDeviceReceiveEvent } from '../SiDevice/ISiDevice';
-import { SiDevice } from '../SiDevice/SiDevice';
-import { SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
-import { SiSendTaskState } from './ISiSendTask';
-import { DIRECT_DEVICE_INITIATED_COMMANDS, SiTargetMultiplexer } from './SiTargetMultiplexer';
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const constants_1 = require("../constants");
+const siProtocol = __importStar(require("../siProtocol"));
+const testUtils = __importStar(require("../testUtils"));
+const ISiDevice_1 = require("../SiDevice/ISiDevice");
+const SiDevice_1 = require("../SiDevice/SiDevice");
+const ISiTargetMultiplexer_1 = require("./ISiTargetMultiplexer");
+const ISiSendTask_1 = require("./ISiSendTask");
+const SiTargetMultiplexer_1 = require("./SiTargetMultiplexer");
 testUtils.useFakeTimers();
 function mockDriver(driver) {
     return driver;
 }
-describe('SiTargetMultiplexer', () => {
-    test('is unique per device', () => {
-        const siDevice = new SiDevice('isUniquePerDevice', {
+(0, globals_1.describe)('SiTargetMultiplexer', () => {
+    (0, globals_1.test)('is unique per device', () => {
+        const siDevice = new SiDevice_1.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);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer1 = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer1 instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
+        const muxer2 = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer2).toBe(muxer1);
     });
-    test('handles receiving', () => {
-        const siDevice = new SiDevice('handlesReceiving', {
+    (0, globals_1.test)('handles receiving', () => {
+        const siDevice = new SiDevice_1.SiDevice('handlesReceiving', {
             driver: mockDriver({})
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const receivedMessages = [];
         const recordMessage = (e) => {
             receivedMessages.push(e.message);
@@ -53,186 +88,186 @@ describe('SiTargetMultiplexer', () => {
             receivedRemoteMessages.push(e.message);
         };
         muxer.addEventListener('remoteMessage', recordRemoteMessage);
-        const directOnlyCommands = Object.keys(DIRECT_DEVICE_INITIATED_COMMANDS).map(Number);
+        const directOnlyCommands = Object.keys(SiTargetMultiplexer_1.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([]);
+        siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage1)));
+        (0, globals_1.expect)(receivedMessages).toEqual([randomMessage1]);
+        (0, globals_1.expect)(receivedDirectMessages).toEqual([]);
+        (0, globals_1.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([]);
+        muxer.target = ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Direct;
+        siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage2)));
+        (0, globals_1.expect)(receivedMessages).toEqual([randomMessage1, randomMessage2]);
+        (0, globals_1.expect)(receivedDirectMessages).toEqual([randomMessage2]);
+        (0, globals_1.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.target = ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Remote;
+        siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage3)));
+        (0, globals_1.expect)(receivedMessages).toEqual([randomMessage1, randomMessage2, randomMessage3]);
+        (0, globals_1.expect)(receivedDirectMessages).toEqual([randomMessage2]);
+        (0, globals_1.expect)(receivedRemoteMessages).toEqual([randomMessage3]);
         muxer.removeEventListener('message', recordMessage);
         muxer.removeEventListener('directMessage', recordDirectMessage);
         muxer.removeEventListener('remoteMessage', recordRemoteMessage);
     });
-    test('handles simple sending', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSending0', {
+    (0, globals_1.test)('handles simple sending', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSending0', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.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);
+            (0, globals_1.expect)(responses.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.sendingFinished = true;
         });
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ sendingFinished: true });
+        (0, globals_1.expect)(timeState).toEqual({ sendingFinished: true });
     }));
-    test('handles sending and waiting for 1 response', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSending1', {
+    (0, globals_1.test)('handles sending and waiting for 1 response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSending1', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.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);
+            (0, globals_1.expect)(responses.length).toBe(1);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.sendingFinished = true;
         });
         setTimeout(() => {
-            siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
+            siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ sendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ sendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ sendingFinished: true });
+        (0, globals_1.expect)(timeState).toEqual({ sendingFinished: true });
     }));
-    test('handles sending and waiting for 1 NAK', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSending1NAK', {
+    (0, globals_1.test)('handles sending and waiting for 1 NAK', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSending1NAK', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { sendingFailed: false };
         muxer.sendMessageToLatestTarget(randomMessage, 1, 2).catch(() => {
-            expect(muxer._test.sendQueue.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.sendingFailed = true;
         });
         setTimeout(() => {
-            siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render({ mode: proto.NAK })));
+            siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render({ mode: constants_1.proto.NAK })));
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ sendingFailed: false });
+        (0, globals_1.expect)(timeState).toEqual({ sendingFailed: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ sendingFailed: true });
+        (0, globals_1.expect)(timeState).toEqual({ sendingFailed: true });
     }));
-    test('handles sending and waiting for 2 responses', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSending2', {
+    (0, globals_1.test)('handles sending and waiting for 2 responses', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSending2', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.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);
+            (0, globals_1.expect)(responses.length).toBe(2);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.sendingFinished = true;
         });
         setTimeout(() => {
-            siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
+            siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
             timeState.receive1 = true;
         }, 1);
         setTimeout(() => {
-            siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
+            siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
             timeState.receive2 = true;
         }, 2);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ receive1: false, receive2: false, sendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: false, receive2: false, sendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ receive1: true, receive2: false, sendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: true, receive2: false, sendingFinished: false });
         yield testUtils.nTimesAsync(10, () => testUtils.advanceTimersByTime(1));
-        expect(timeState).toEqual({ receive1: true, receive2: true, sendingFinished: true });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: true, receive2: true, sendingFinished: true });
     }));
-    test('handles sending and timing out waiting for 1 response', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSending1Timeout', {
+    (0, globals_1.test)('handles sending and timing out waiting for 1 response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSending1Timeout', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { timedOut: false };
         muxer.sendMessageToLatestTarget(randomMessage, 1, 1).catch(() => {
-            expect(muxer._test.sendQueue.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.timedOut = true;
         });
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ timedOut: false });
+        (0, globals_1.expect)(timeState).toEqual({ timedOut: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ timedOut: true });
+        (0, globals_1.expect)(timeState).toEqual({ timedOut: true });
     }));
-    test('handles sending and timing out waiting for 2 responses', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSending2Timeout', {
+    (0, globals_1.test)('handles sending and timing out waiting for 2 responses', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSending2Timeout', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.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);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.timedOut = true;
         });
         setTimeout(() => {
-            siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
+            siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render(randomMessage)));
             timeState.receive1 = true;
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ receive1: false, timedOut: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: false, timedOut: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ receive1: true, timedOut: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: true, timedOut: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ receive1: true, timedOut: true });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: true, timedOut: true });
     }));
-    test('does not time out, if it already succeeded', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('noTimeoutIfSucceeded', {
+    (0, globals_1.test)('does not time out, if it already succeeded', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('noTimeoutIfSucceeded', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeoutInMiliseconds = 2;
         const timeState = {
@@ -250,43 +285,43 @@ describe('SiTargetMultiplexer', () => {
             timeState.timedOut = true;
         });
         setTimeout(() => {
-            muxer._test.sendQueue[0].state = SiSendTaskState.Succeeded;
+            muxer._test.sendQueue[0].state = ISiSendTask_1.SiSendTaskState.Succeeded;
             timeState.madeSuccessful = true;
         }, 1);
         setTimeout(() => {
             timeState.timeoutPassed = true;
         }, timeoutInMiliseconds);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({
+        (0, globals_1.expect)(timeState).toEqual({
             madeSuccessful: false,
             timeoutPassed: false,
             timedOut: false,
             succeeded: false
         });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({
+        (0, globals_1.expect)(timeState).toEqual({
             madeSuccessful: true,
             timeoutPassed: false,
             timedOut: false,
             succeeded: false
         });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({
+        (0, globals_1.expect)(timeState).toEqual({
             madeSuccessful: true,
             timeoutPassed: true,
             timedOut: false,
             succeeded: false
         });
     }));
-    test('does not succeed, if response for different command arrives', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('differentCommand', {
+    (0, globals_1.test)('does not succeed, if response for different command arrives', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('differentCommand', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { receive1: false, timedOut: false, succeeded: false };
         muxer
@@ -295,106 +330,106 @@ describe('SiTargetMultiplexer', () => {
             timeState.succeeded = true;
         })
             .catch(() => {
-            expect(muxer._test.sendQueue.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.timedOut = true;
         });
         setTimeout(() => {
-            siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render({
+            siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render({
                 command: testUtils.getRandomByteExcept([randomMessage.command]),
                 parameters: randomMessage.parameters
             })));
             timeState.receive1 = true;
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ receive1: false, timedOut: false, succeeded: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: false, timedOut: false, succeeded: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ receive1: true, timedOut: false, succeeded: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: true, timedOut: false, succeeded: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ receive1: true, timedOut: true, succeeded: false });
+        (0, globals_1.expect)(timeState).toEqual({ receive1: true, timedOut: true, succeeded: false });
     }));
-    test('cannot send to unopened SiDevice', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('cannotSendToUnopened', {
+    (0, globals_1.test)('cannot send to unopened SiDevice', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('cannotSendToUnopened', {
             driver: mockDriver({})
         });
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { timedOut: false };
         muxer.sendMessageToLatestTarget(randomMessage, 1, 1).catch(() => {
-            expect(muxer._test.sendQueue.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.timedOut = true;
         });
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ timedOut: false });
+        (0, globals_1.expect)(timeState).toEqual({ timedOut: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ timedOut: true });
+        (0, globals_1.expect)(timeState).toEqual({ timedOut: true });
     }));
-    test('handles sending as soon as device is openend', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesSendingAsSoonAsOpened', {
+    (0, globals_1.test)('handles sending as soon as device is openend', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('handlesSendingAsSoonAsOpened', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.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);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.sendingFinished = true;
         });
         setTimeout(() => {
-            siDevice.setState(SiDeviceState.Opened);
+            siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
             timeState.deviceOpened = true;
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ deviceOpened: false, sendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: false, sendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ deviceOpened: true, sendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: true, sendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ deviceOpened: true, sendingFinished: true });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: true, sendingFinished: true });
     }));
-    test('sends all as soon as device is openend', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('sendsAllAsSoonAsOpened', {
+    (0, globals_1.test)('sends all as soon as device is openend', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('sendsAllAsSoonAsOpened', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.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);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.allSendingFinished = true;
         });
         setTimeout(() => {
-            siDevice.setState(SiDeviceState.Opened);
+            siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
             timeState.deviceOpened = true;
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ deviceOpened: false, numSuccess: 0, allSendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: false, numSuccess: 0, allSendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ deviceOpened: true, numSuccess: 0, allSendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: true, numSuccess: 0, allSendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ deviceOpened: true, numSuccess: 1, allSendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: true, numSuccess: 1, allSendingFinished: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ deviceOpened: true, numSuccess: 2, allSendingFinished: false });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: true, numSuccess: 2, allSendingFinished: false });
         yield testUtils.advanceTimersByTime(0); // for Promise.all
-        expect(timeState).toEqual({ deviceOpened: true, numSuccess: 2, allSendingFinished: true });
+        (0, globals_1.expect)(timeState).toEqual({ deviceOpened: true, numSuccess: 2, allSendingFinished: true });
     }));
-    test('aborts sending as soon as device is closed', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('abortsAllAsSoonAsClosed', {
+    (0, globals_1.test)('aborts sending as soon as device is closed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('abortsAllAsSoonAsClosed', {
             driver: mockDriver({
                 send: () => Promise.resolve()
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = {
             numSuccess: 0,
@@ -411,143 +446,143 @@ describe('SiTargetMultiplexer', () => {
             timeState.numAbort = (timeState.numAbort || 0) + 1;
         }, () => { });
         Promise.all([getMuxerPromise(), getMuxerPromise(), getMuxerPromise()]).then(() => {
-            expect(muxer._test.sendQueue.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.allSendingFinished = true;
         }, () => { });
         setTimeout(() => {
-            siDevice.setState(SiDeviceState.Closing);
+            siDevice.setState(ISiDevice_1.SiDeviceState.Closing);
             timeState.deviceClosed = true;
         }, 1);
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({
+        (0, globals_1.expect)(timeState).toEqual({
             numSuccess: 1,
             numAbort: 0,
             deviceClosed: false,
             allSendingFinished: false
         });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({
+        (0, globals_1.expect)(timeState).toEqual({
             numSuccess: 1,
             numAbort: 2,
             deviceClosed: true,
             allSendingFinished: false
         });
         yield testUtils.advanceTimersByTime(0); // for Promise.all (not called)
-        expect(timeState).toEqual({
+        (0, globals_1.expect)(timeState).toEqual({
             numSuccess: 1,
             numAbort: 2,
             deviceClosed: true,
             allSendingFinished: false
         });
     }));
-    test('handles device failing to send', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('handlesDeviceFailingToSend', {
+    (0, globals_1.test)('handles device failing to send', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.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);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        (0, globals_1.expect)(muxer instanceof SiTargetMultiplexer_1.SiTargetMultiplexer).toBe(true);
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { timedOut: false };
         muxer.sendMessageToLatestTarget(randomMessage, 1, 1).catch(() => {
-            expect(muxer._test.sendQueue.length).toBe(0);
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.timedOut = true;
         });
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ timedOut: false });
+        (0, globals_1.expect)(timeState).toEqual({ timedOut: false });
         yield testUtils.advanceTimersByTime(1);
-        expect(timeState).toEqual({ timedOut: true });
+        (0, globals_1.expect)(timeState).toEqual({ timedOut: true });
     }));
-    test('cannot send to unknown target', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('undefinedTarget', { driver: mockDriver({}) });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
+    (0, globals_1.test)('cannot send to unknown target', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('undefinedTarget', { driver: mockDriver({}) });
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        muxer.latestTarget = ISiTargetMultiplexer_1.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);
+        muxer.sendMessage(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Unknown, randomMessage, 1, 1).catch(() => {
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.setToUnknownFailed = true;
         });
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ setToUnknownFailed: true });
+        (0, globals_1.expect)(timeState).toEqual({ setToUnknownFailed: true });
     }));
-    test('cannot send to switching target', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('switchingTarget', { driver: mockDriver({}) });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
+    (0, globals_1.test)('cannot send to switching target', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('switchingTarget', { driver: mockDriver({}) });
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        muxer.latestTarget = ISiTargetMultiplexer_1.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);
+        muxer.sendMessage(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Switching, randomMessage, 1, 1).catch(() => {
+            (0, globals_1.expect)(muxer._test.sendQueue.length).toBe(0);
             timeState.setToSwitchingFailed = true;
         });
         yield testUtils.advanceTimersByTime(0);
-        expect(timeState).toEqual({ setToSwitchingFailed: true });
+        (0, globals_1.expect)(timeState).toEqual({ setToSwitchingFailed: true });
     }));
-    test('handles error switching target', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('errorSwitchingTarget', {
+    (0, globals_1.test)('handles error switching target', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('errorSwitchingTarget', {
             driver: mockDriver({
                 send: () => Promise.reject(new Error('test'))
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        muxer.latestTarget = ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Direct;
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { setTargetFailed: false };
-        muxer.sendMessage(SiTargetMultiplexerTarget.Remote, randomMessage, 1, 1).catch(() => {
+        muxer.sendMessage(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Remote, randomMessage, 1, 1).catch(() => {
             timeState.setTargetFailed = true;
         });
         yield testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-        expect(muxer.target).toEqual(SiTargetMultiplexerTarget.Unknown);
-        expect(timeState).toEqual({ setTargetFailed: true });
+        (0, globals_1.expect)(muxer.target).toEqual(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Unknown);
+        (0, globals_1.expect)(timeState).toEqual({ setTargetFailed: true });
     }));
-    test('handles unclear target switch response', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('errorSwitchingTarget', {
+    (0, globals_1.test)('handles unclear target switch response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('errorSwitchingTarget', {
             driver: mockDriver({
                 send: () => {
                     setTimeout(() => {
-                        siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, siProtocol.render({
-                            command: proto.cmd.SET_MS,
-                            parameters: [SiTargetMultiplexerTarget.Direct]
+                        siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, siProtocol.render({
+                            command: constants_1.proto.cmd.SET_MS,
+                            parameters: [ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Direct]
                         })));
                     }, 0);
                     return Promise.resolve();
                 }
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
-        muxer.latestTarget = SiTargetMultiplexerTarget.Direct;
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
+        muxer.latestTarget = ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Direct;
         const randomMessage = testUtils.getRandomMessage({});
         const timeState = { setTargetFailed: false };
-        muxer.sendMessage(SiTargetMultiplexerTarget.Remote, randomMessage, 1, 1).catch(() => {
+        muxer.sendMessage(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Remote, randomMessage, 1, 1).catch(() => {
             timeState.setTargetFailed = true;
         });
         yield testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
-        expect(muxer.target).toEqual(SiTargetMultiplexerTarget.Unknown);
-        expect(timeState).toEqual({ setTargetFailed: true });
+        (0, globals_1.expect)(muxer.target).toEqual(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Unknown);
+        (0, globals_1.expect)(timeState).toEqual({ setTargetFailed: true });
     }));
-    test('handles direct device-initiated command', () => __awaiter(void 0, void 0, void 0, function* () {
-        const siDevice = new SiDevice('errorSwitchingTarget', {
+    (0, globals_1.test)('handles direct device-initiated command', () => __awaiter(void 0, void 0, void 0, function* () {
+        const siDevice = new SiDevice_1.SiDevice('errorSwitchingTarget', {
             driver: mockDriver({
                 send: () => Promise.reject(new Error('test'))
             })
         });
-        siDevice.setState(SiDeviceState.Opened);
-        const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
+        siDevice.setState(ISiDevice_1.SiDeviceState.Opened);
+        const muxer = SiTargetMultiplexer_1.SiTargetMultiplexer.fromSiDevice(siDevice);
         const deviceInitiatedMessage = siProtocol.render({
-            command: proto.cmd.SI5_DET,
+            command: constants_1.proto.cmd.SI5_DET,
             parameters: [0x00, 0x0a, 0x00, 0x04, 0x19, 0x02]
         });
-        siDevice.dispatchEvent('receive', new SiDeviceReceiveEvent(siDevice, deviceInitiatedMessage));
+        siDevice.dispatchEvent('receive', new ISiDevice_1.SiDeviceReceiveEvent(siDevice, deviceInitiatedMessage));
         yield testUtils.nTimesAsync(10, () => testUtils.advanceTimersByTime(1));
-        expect(muxer.target).toEqual(SiTargetMultiplexerTarget.Direct);
-        expect(muxer.latestTarget).toEqual(SiTargetMultiplexerTarget.Direct);
+        (0, globals_1.expect)(muxer.target).toEqual(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Direct);
+        (0, globals_1.expect)(muxer.latestTarget).toEqual(ISiTargetMultiplexer_1.SiTargetMultiplexerTarget.Direct);
     }));
 });
 //# sourceMappingURL=SiTargetMultiplexer.test.js.map