zigbee-herdsman 3.5.1 → 4.0.0

package/test/adapter/ember/ezsp.test.ts

@@ -0,0 +1,386 @@
+import type {Mock, MockInstance} from "vitest";
+
+import {MockBinding} from "@serialport/binding-mock";
+
+import {EzspStatus} from "../../../src/adapter/ember/enums";
+import {Ezsp} from "../../../src/adapter/ember/ezsp/ezsp";
+import {
+    ASH_ACK_FIRST_BYTES,
+    INCOMING_MESSAGE_HANDLER_FN2_ASH_RAW,
+    MESSAGE_SENT_HANDLER_FN0_ASH_RAW,
+    MESSAGE_SENT_HANDLER_FN1_ASH_RAW,
+    RCED_DATA_VERSION,
+    RCED_DATA_VERSION_RES,
+    RCED_DATA_WITH_CRC_ERROR,
+    RCED_ERROR_WATCHDOG_BYTES,
+    RECD_ERROR_ACK_TIMEOUT_BYTES,
+    RECD_RSTACK_BYTES,
+    SEND_ACK_FIRST_BYTES,
+    SEND_DATA_VERSION,
+    SEND_RST_BYTES,
+    SEND_UNICAST_REPLY_FN0_ASH_RAW,
+    SET_POLICY_REPLY_FN1_ASH_RAW,
+    adapterSONOFFDongleE,
+} from "./consts";
+
+const emitFromSerial = async (ezsp: Ezsp, data: Buffer, skipAdvanceTimers = false): Promise<void> => {
+    //@ts-expect-error private
+    ezsp.ash.serialPort.port.emitData(Buffer.from(data));
+
+    if (!skipAdvanceTimers) {
+        await vi.advanceTimersByTimeAsync(1000);
+    }
+};
+
+const advanceTime100ms = async (times: number): Promise<void> => {
+    for (let i = 0; i < times; i++) {
+        await vi.advanceTimersByTimeAsync(100);
+    }
+};
+
+const advanceTimeToRSTACK = async (): Promise<void> => {
+    // mock time waited for real RSTACK (avg time of 1100ms)
+    await advanceTime100ms(10);
+};
+
+const POST_RSTACK_SERIAL_BYTES = Buffer.from([...SEND_RST_BYTES, ...ASH_ACK_FIRST_BYTES]);
+const mocks: Mock[] = [];
+
+describe("Ember Ezsp Layer", () => {
+    const openOpts = {path: "/dev/ttyACM0", baudRate: 115200, binding: MockBinding};
+    let ezsp: Ezsp;
+
+    beforeAll(() => {
+        vi.useRealTimers();
+    });
+
+    afterAll(() => {});
+
+    beforeEach(() => {
+        for (const mock of mocks) {
+            mock.mockClear();
+        }
+
+        ezsp = new Ezsp(openOpts);
+        MockBinding.createPort("/dev/ttyACM0", {record: true, ...adapterSONOFFDongleE});
+        vi.useFakeTimers();
+    });
+
+    afterEach(async () => {
+        vi.useRealTimers();
+        await ezsp.stop();
+        MockBinding.reset();
+    });
+
+    it("Starts ASH layer normally", async () => {
+        const startResult = ezsp.start();
+
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ezsp.checkConnection()).toBeTruthy();
+    });
+
+    it("Starts ASH layer ignoring noise from port", async () => {
+        const ashEmitSpy = vi.spyOn(ezsp.ash, "emit");
+        // @ts-expect-error private
+        const onAshFatalErrorSpy = vi.spyOn(ezsp, "onAshFatalError");
+        const startResult = ezsp.start();
+
+        await advanceTime100ms(2);
+        await emitFromSerial(ezsp, RCED_DATA_WITH_CRC_ERROR, true);
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ezsp.checkConnection()).toBeTruthy();
+        expect(ezsp.ash.counters.rxCrcErrors).toStrictEqual(1);
+        expect(ashEmitSpy).not.toHaveBeenCalled();
+        expect(onAshFatalErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it("Starts ASH layer even when received ERROR from port", async () => {
+        const startResult = ezsp.start();
+
+        await advanceTime100ms(2);
+        await emitFromSerial(ezsp, Buffer.from(RECD_ERROR_ACK_TIMEOUT_BYTES), true);
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ezsp.checkConnection()).toBeTruthy();
+    });
+
+    it("Starts ASH layer when received ERROR RESET_WATCHDOG from port", async () => {
+        const startResult = ezsp.start();
+
+        await advanceTime100ms(2);
+        await emitFromSerial(ezsp, Buffer.from(RCED_ERROR_WATCHDOG_BYTES), true);
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ezsp.checkConnection()).toBeTruthy();
+    });
+
+    it("Starts ASH layer when received duplicate RSTACK from port right after first ACK", async () => {
+        const ashEmitSpy = vi.spyOn(ezsp.ash, "emit");
+        let restart: () => Promise<EzspStatus>;
+        // @ts-expect-error private
+        const onAshFatalErrorSpy = vi.spyOn(ezsp, "onAshFatalError").mockImplementationOnce((_status: EzspStatus): void => {
+            // mimic EmberAdapter onNcpNeedsResetAndInit
+            restart = async () => {
+                vi.useRealTimers();
+                await ezsp.stop();
+                vi.useFakeTimers();
+
+                ezsp = new Ezsp(openOpts);
+                const startResult = ezsp.start();
+
+                await advanceTimeToRSTACK();
+                await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+                return await Promise.resolve(startResult);
+            };
+        });
+        const startResult = ezsp.start();
+
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS); // dup is received after this returns
+        expect(ezsp.checkConnection()).toBeFalsy();
+        // @ts-expect-error set via emit
+        expect(restart).toBeDefined();
+        // @ts-expect-error set via emit
+        await expect(restart()).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ashEmitSpy).toHaveBeenCalledWith("fatalError", EzspStatus.HOST_FATAL_ERROR);
+        expect(onAshFatalErrorSpy).toHaveBeenCalledWith(EzspStatus.HOST_FATAL_ERROR);
+        expect(ezsp.checkConnection()).toBeTruthy();
+    });
+
+    it("Starts ASH layer with messy hardware flow control", async () => {
+        // https://github.com/Koenkk/zigbee-herdsman/issues/943
+        const ashEmitSpy = vi.spyOn(ezsp.ash, "emit");
+        let restart: () => Promise<EzspStatus>;
+        // @ts-expect-error private
+        const onAshFatalErrorSpy = vi.spyOn(ezsp, "onAshFatalError").mockImplementationOnce((_status: EzspStatus): void => {
+            // mimic EmberAdapter onNcpNeedsResetAndInit
+            restart = async () => {
+                vi.useRealTimers();
+                await ezsp.stop();
+                vi.useFakeTimers();
+
+                ezsp = new Ezsp(openOpts);
+                const startResult = ezsp.start();
+
+                await advanceTimeToRSTACK();
+                await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+                return await Promise.resolve(startResult);
+            };
+        });
+        const startResult = ezsp.start();
+
+        await advanceTime100ms(2);
+        await emitFromSerial(ezsp, Buffer.from(RCED_ERROR_WATCHDOG_BYTES), true);
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS); // dup is received after this returns
+        expect(ezsp.checkConnection()).toBeFalsy();
+        // @ts-expect-error set via emit
+        expect(restart).toBeDefined();
+        // @ts-expect-error set via emit
+        await expect(restart()).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ashEmitSpy).toHaveBeenCalledWith("fatalError", EzspStatus.HOST_FATAL_ERROR);
+        expect(onAshFatalErrorSpy).toHaveBeenCalledWith(EzspStatus.HOST_FATAL_ERROR);
+        expect(ezsp.checkConnection()).toBeTruthy();
+    });
+
+    it("Restarts ASH layer when received ERROR from port", async () => {
+        let restart: () => Promise<EzspStatus>;
+        // @ts-expect-error private
+        const onAshFatalErrorSpy = vi.spyOn(ezsp, "onAshFatalError").mockImplementationOnce((_status: EzspStatus): void => {
+            // mimic EmberAdapter onNcpNeedsResetAndInit
+            restart = async () => {
+                vi.useRealTimers();
+                await ezsp.stop();
+                vi.useFakeTimers();
+
+                ezsp = new Ezsp(openOpts);
+                const startResult = ezsp.start();
+
+                await advanceTimeToRSTACK();
+                await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+                return await Promise.resolve(startResult);
+            };
+        });
+        const startResult = ezsp.start();
+
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ezsp.checkConnection()).toBeTruthy();
+        // started clean
+
+        const version = ezsp.ezspVersion(13);
+
+        await vi.advanceTimersByTimeAsync(1000);
+        await emitFromSerial(ezsp, RCED_DATA_VERSION);
+        await vi.advanceTimersByTimeAsync(1000);
+        await expect(version).resolves.toStrictEqual(RCED_DATA_VERSION_RES);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(
+            Buffer.from([...POST_RSTACK_SERIAL_BYTES, ...SEND_DATA_VERSION, ...SEND_ACK_FIRST_BYTES]),
+        );
+
+        await vi.advanceTimersByTimeAsync(10000); // any time after startup sequence
+
+        await emitFromSerial(ezsp, Buffer.from(RECD_ERROR_ACK_TIMEOUT_BYTES));
+        expect(ezsp.checkConnection()).toBeFalsy();
+        // @ts-expect-error set via emit
+        expect(restart).toBeDefined();
+        // @ts-expect-error set via emit
+        await expect(restart()).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(onAshFatalErrorSpy).toHaveBeenCalledWith(EzspStatus.HOST_FATAL_ERROR);
+        expect(ezsp.checkConnection()).toBeTruthy();
+    });
+
+    it("Throws on send command with ASH connection problem", async () => {
+        const startResult = ezsp.start();
+
+        await advanceTimeToRSTACK();
+        await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+        await expect(startResult).resolves.toStrictEqual(EzspStatus.SUCCESS);
+        //@ts-expect-error private
+        expect(ezsp.ash.serialPort.port.recording).toStrictEqual(POST_RSTACK_SERIAL_BYTES);
+        expect(ezsp.checkConnection()).toBeTruthy();
+        // started clean
+
+        // mimic error that doesn't trigger FATAL_ERROR event
+        await ezsp.ash.stop();
+
+        await expect(ezsp.ezspVersion(13)).rejects.toThrow(EzspStatus[EzspStatus.NOT_CONNECTED]);
+    });
+
+    describe("When connected", () => {
+        let callbackDispatchSpy: MockInstance;
+        const mockResponseWaiterResolve = vi.fn();
+        let ashSendExecSpy: MockInstance;
+
+        beforeEach(async () => {
+            const startResult = ezsp.start();
+
+            await advanceTimeToRSTACK();
+            await emitFromSerial(ezsp, Buffer.from(RECD_RSTACK_BYTES));
+            await startResult;
+            expect(ezsp.checkConnection()).toBeTruthy();
+
+            callbackDispatchSpy = vi.spyOn(ezsp, "callbackDispatch").mockImplementation(vi.fn());
+            ashSendExecSpy = vi.spyOn(ezsp.ash, "sendExec");
+
+            mockResponseWaiterResolve.mockClear();
+        });
+
+        it("Parses successive valid incoming frames", async () => {
+            // @ts-expect-error private
+            ezsp.responseWaiter = {timer: setTimeout(() => {}, 15000), resolve: mockResponseWaiterResolve};
+
+            await emitFromSerial(ezsp, Buffer.from(SEND_UNICAST_REPLY_FN0_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(0);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(1);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledWith(EzspStatus.SUCCESS);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=52:"SEND_UNICAST" Seq=39 Len=10]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(1);
+
+            await emitFromSerial(ezsp, Buffer.from(MESSAGE_SENT_HANDLER_FN1_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(1);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(1);
+            expect(ezsp.callbackFrameToString).toStrictEqual(`[CBFRAME: ID=63:"MESSAGE_SENT_HANDLER" Seq=39 Len=26]`);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=52:"SEND_UNICAST" Seq=39 Len=10]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(2);
+
+            await emitFromSerial(ezsp, Buffer.from(INCOMING_MESSAGE_HANDLER_FN2_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(2);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(1);
+            expect(ezsp.callbackFrameToString).toStrictEqual(`[CBFRAME: ID=69:"INCOMING_MESSAGE_HANDLER" Seq=39 Len=42]`);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=52:"SEND_UNICAST" Seq=39 Len=10]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(3);
+        });
+
+        it("Parses valid incoming callback frame while waiting for response frame", async () => {
+            // @ts-expect-error private
+            ezsp.responseWaiter = {timer: setTimeout(() => {}, 15000), resolve: mockResponseWaiterResolve};
+
+            await emitFromSerial(ezsp, Buffer.from(MESSAGE_SENT_HANDLER_FN0_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(1);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(0);
+            expect(ezsp.callbackFrameToString).toStrictEqual(`[CBFRAME: ID=63:"MESSAGE_SENT_HANDLER" Seq=39 Len=26]`);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=0:"VERSION" Seq=0 Len=0]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(1);
+
+            await emitFromSerial(ezsp, Buffer.from(SET_POLICY_REPLY_FN1_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(1);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(1);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledWith(EzspStatus.SUCCESS);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=85:"SET_POLICY" Seq=79 Len=9]`);
+            expect(ezsp.callbackFrameToString).toStrictEqual(`[CBFRAME: ID=63:"MESSAGE_SENT_HANDLER" Seq=39 Len=26]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(2);
+        });
+
+        it("Parses invalid incoming frame", async () => {
+            vi.spyOn(ezsp, "validateReceivedFrame").mockReturnValueOnce(EzspStatus.ERROR_WRONG_DIRECTION);
+
+            // @ts-expect-error private
+            ezsp.responseWaiter = {timer: setTimeout(() => {}, 15000), resolve: mockResponseWaiterResolve};
+
+            await emitFromSerial(ezsp, Buffer.from(SEND_UNICAST_REPLY_FN0_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(0);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(1);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledWith(EzspStatus.ERROR_WRONG_DIRECTION);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=52:"SEND_UNICAST" Seq=39 Len=10]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it("Parses invalid incoming callback frame", async () => {
+            vi.spyOn(ezsp, "validateReceivedFrame").mockReturnValueOnce(EzspStatus.ERROR_WRONG_DIRECTION);
+
+            await emitFromSerial(ezsp, Buffer.from(MESSAGE_SENT_HANDLER_FN0_ASH_RAW, "hex"));
+            await vi.advanceTimersByTimeAsync(1000);
+
+            expect(callbackDispatchSpy).toHaveBeenCalledTimes(0);
+            expect(mockResponseWaiterResolve).toHaveBeenCalledTimes(0);
+            expect(ezsp.callbackFrameToString).toStrictEqual(`[CBFRAME: ID=63:"MESSAGE_SENT_HANDLER" Seq=39 Len=26]`);
+            expect(ezsp.frameToString).toStrictEqual(`[FRAME: ID=0:"VERSION" Seq=0 Len=0]`);
+            expect(ashSendExecSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/test/adapter/ember/ezspBuffalo.test.ts

@@ -0,0 +1,92 @@
+import {SLStatus} from "../../../src/adapter/ember/enums";
+import {EzspBuffalo} from "../../../src/adapter/ember/ezsp/buffalo";
+import {
+    EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX,
+    EZSP_FRAME_CONTROL_COMMAND,
+    EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK,
+    EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET,
+    EZSP_FRAME_CONTROL_SLEEP_MODE_MASK,
+    EZSP_FRAME_ID_INDEX,
+    EZSP_MAX_FRAME_LENGTH,
+    EZSP_PARAMETERS_INDEX,
+    EZSP_SEQUENCE_INDEX,
+} from "../../../src/adapter/ember/ezsp/consts";
+import {EzspFrameID} from "../../../src/adapter/ember/ezsp/enums";
+import {lowByte} from "../../../src/adapter/ember/utils/math";
+
+describe("Ember EZSP Buffalo", () => {
+    let buffalo: EzspBuffalo;
+
+    beforeAll(async () => {});
+
+    afterAll(async () => {});
+
+    beforeEach(() => {
+        buffalo = new EzspBuffalo(Buffer.alloc(EZSP_MAX_FRAME_LENGTH));
+    });
+
+    afterEach(() => {});
+
+    it("Is empty after init", () => {
+        expect(buffalo.getWritten()).toStrictEqual(Buffer.from([]));
+    });
+
+    it("Writes & read at position without altering internal position tracker", () => {
+        // mock send `version` command logic flow
+        buffalo.setPosition(EZSP_PARAMETERS_INDEX);
+        buffalo.setCommandByte(EZSP_FRAME_ID_INDEX, lowByte(EzspFrameID.VERSION));
+        buffalo.setCommandByte(EZSP_SEQUENCE_INDEX, 0);
+        buffalo.setCommandByte(
+            EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX,
+            EZSP_FRAME_CONTROL_COMMAND |
+                (0x00 & EZSP_FRAME_CONTROL_SLEEP_MODE_MASK) |
+                ((0x00 << EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET) & EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK),
+        );
+        buffalo.writeUInt8(12); // desiredProtocolVersion
+
+        expect(buffalo.getWritten()).toStrictEqual(Buffer.from([0x00, 0x00, 0x00, 0x0c]));
+
+        expect(buffalo.getCommandByte(EZSP_FRAME_ID_INDEX)).toStrictEqual(lowByte(EzspFrameID.VERSION));
+        expect(buffalo.getCommandByte(EZSP_SEQUENCE_INDEX)).toStrictEqual(0);
+        expect(buffalo.getCommandByte(EZSP_EXTENDED_FRAME_CONTROL_LB_INDEX)).toStrictEqual(
+            EZSP_FRAME_CONTROL_COMMAND |
+                (0x00 & EZSP_FRAME_CONTROL_SLEEP_MODE_MASK) |
+                ((0x00 << EZSP_FRAME_CONTROL_NETWORK_INDEX_OFFSET) & EZSP_FRAME_CONTROL_NETWORK_INDEX_MASK),
+        );
+    });
+
+    it("Maps EmberStatus/EzspStatus to SLStatus", () => {
+        buffalo.setCommandByte(0, 0x00);
+        buffalo.setCommandByte(1, 0x00);
+        buffalo.setCommandByte(2, 0x00);
+        buffalo.setCommandByte(3, 0x00);
+        // zero always zero
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d)).toStrictEqual(SLStatus.OK);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d, false)).toStrictEqual(SLStatus.OK);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0e)).toStrictEqual(SLStatus.OK);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0e, false)).toStrictEqual(SLStatus.OK);
+
+        buffalo.setCommandByte(0, 0x02);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d)).toStrictEqual(SLStatus.INVALID_PARAMETER);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d, false)).toStrictEqual(SLStatus.ZIGBEE_EZSP_ERROR);
+
+        buffalo.setCommandByte(0, 0x9c);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d)).toStrictEqual(SLStatus.ZIGBEE_NETWORK_OPENED);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d, false)).toStrictEqual(SLStatus.ZIGBEE_EZSP_ERROR);
+
+        // no mapped value
+        buffalo.setCommandByte(0, 0x4b);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d)).toStrictEqual(SLStatus.BUS_ERROR);
+        buffalo.setPosition(0);
+        expect(buffalo.readStatus(0x0d, false)).toStrictEqual(SLStatus.ZIGBEE_EZSP_ERROR);
+    });
+});

package/test/adapter/ember/ezspError.test.ts

@@ -0,0 +1,11 @@
+import {EzspError} from "../../../src/adapter/ember/ezspError";
+import {EzspStatus} from "../../../src/adapter/ezsp/driver/types";
+
+describe("Ezsp Error", () => {
+    it("Creates error", () => {
+        const error = new EzspError(EzspStatus.ASH_ACK_TIMEOUT);
+
+        expect(error.message).toStrictEqual("ASH_ACK_TIMEOUT");
+        expect(error.code).toStrictEqual(EzspStatus.ASH_ACK_TIMEOUT);
+    });
+});

package/test/adapter/ember/math.test.ts

@@ -0,0 +1,205 @@
+import * as m from "../../../src/adapter/ember/utils/math";
+
+const ASH_CRC_INIT = 0xffff;
+const B32 = 0xbeefface;
+
+describe("Ember Math utils", () => {
+    it("mod8", () => {
+        let t = m.mod8(0x00);
+        expect(t).toStrictEqual(0);
+        t = m.mod8(0x03);
+        expect(t).toStrictEqual(3);
+        t = m.mod8(0x07);
+        expect(t).toStrictEqual(7);
+        t = m.mod8(0x08);
+        expect(t).toStrictEqual(0);
+        t = m.mod8(0x10);
+        expect(t).toStrictEqual(0);
+        t = m.mod8(0xfe);
+        expect(t).toStrictEqual(6);
+        t = m.mod8(0xff);
+        expect(t).toStrictEqual(7);
+    });
+    it("inc8", () => {
+        let t = m.inc8(0x00);
+        expect(t).toStrictEqual(1);
+        t = m.inc8(0x03);
+        expect(t).toStrictEqual(4);
+        t = m.inc8(0x07);
+        expect(t).toStrictEqual(0);
+        t = m.inc8(0x08);
+        expect(t).toStrictEqual(1);
+        t = m.inc8(0x10);
+        expect(t).toStrictEqual(1);
+        t = m.inc8(0xfe);
+        expect(t).toStrictEqual(7);
+        t = m.inc8(0xff);
+        expect(t).toStrictEqual(0);
+    });
+    it("withinRange", () => {
+        let t = m.withinRange(0x00, 0x04, 0x07);
+        expect(t).toStrictEqual(true);
+        t = m.withinRange(0x00, 0x04, 0x08);
+        expect(t).toStrictEqual(false);
+        t = m.withinRange(0xaa, 0xac, 0xfe);
+        expect(t).toStrictEqual(true);
+        t = m.withinRange(0x00, 0x04, 0xf8);
+        expect(t).toStrictEqual(false);
+    });
+    it("halCommonCrc16", () => {
+        let t = m.halCommonCrc16(0x00, ASH_CRC_INIT);
+        expect(t).toStrictEqual(57840);
+        t = m.halCommonCrc16(0x03, t);
+        expect(t).toStrictEqual(11628);
+        t = m.halCommonCrc16(0xfe, t);
+        expect(t).toStrictEqual(38686);
+        t = m.halCommonCrc16(0xa5, t);
+        expect(t).toStrictEqual(2065);
+    });
+    it("lowBits", () => {
+        let t = m.lowBits(10);
+        expect(t).toStrictEqual(10);
+        t = m.lowBits(100);
+        expect(t).toStrictEqual(4);
+    });
+    it("highBits", () => {
+        let t = m.highBits(10);
+        expect(t).toStrictEqual(0);
+        t = m.highBits(100);
+        expect(t).toStrictEqual(6);
+    });
+    it("lowByte", () => {
+        let t = m.lowByte(10);
+        expect(t).toStrictEqual(10);
+        t = m.lowByte(100);
+        expect(t).toStrictEqual(100);
+        t = m.lowByte(1000);
+        expect(t).toStrictEqual(232);
+        t = m.lowByte(255);
+        expect(t).toStrictEqual(255);
+        t = m.lowByte(1024);
+        expect(t).toStrictEqual(0);
+        t = m.lowByte(B32);
+        expect(t).toStrictEqual(206);
+    });
+    it("highByte", () => {
+        let t = m.highByte(10);
+        expect(t).toStrictEqual(0);
+        t = m.highByte(100);
+        expect(t).toStrictEqual(0);
+        t = m.highByte(1000);
+        expect(t).toStrictEqual(3);
+        t = m.highByte(255);
+        expect(t).toStrictEqual(0);
+        t = m.highByte(1024);
+        expect(t).toStrictEqual(4);
+        t = m.highByte(B32);
+        expect(t).toStrictEqual(250);
+    });
+    it("highLowToInt", () => {
+        let t = m.highLowToInt(254, 10);
+        expect(t).toStrictEqual(65034);
+        t = m.highLowToInt(10, 100);
+        expect(t).toStrictEqual(2660);
+        t = m.highLowToInt(1000, 2000);
+        expect(t).toStrictEqual(256208);
+        t = m.highLowToInt(355, 255);
+        expect(t).toStrictEqual(91135);
+        t = m.highLowToInt(123, 1024);
+        expect(t).toStrictEqual(31488);
+        t = m.highLowToInt(1, B32);
+        expect(t).toStrictEqual(462);
+        t = m.highLowToInt(B32, 1);
+        expect(t).toStrictEqual(16436737);
+    });
+    it("bit", () => {
+        let t = m.bit(11);
+        expect(t).toStrictEqual(2048);
+        t = m.bit(15);
+        expect(t).toStrictEqual(32768);
+        t = m.bit(26);
+        expect(t).toStrictEqual(67108864);
+        t = m.bit(11) | m.bit(15) | m.bit(20) | m.bit(25);
+        expect(t).toStrictEqual(34637824);
+        t =
+            m.bit(12) |
+            m.bit(13) |
+            m.bit(14) |
+            m.bit(16) |
+            m.bit(17) |
+            m.bit(18) |
+            m.bit(19) |
+            m.bit(21) |
+            m.bit(22) |
+            m.bit(23) |
+            m.bit(24) |
+            m.bit(26);
+        expect(t).toStrictEqual(99577856);
+        t = 53 & m.bit(0);
+        expect(t).toStrictEqual(1);
+        t = 53 & m.bit(3);
+        expect(t).toStrictEqual(0);
+        t = 53 | m.bit(0);
+        expect(t).toStrictEqual(53);
+        t = 53 | m.bit(3);
+        expect(t).toStrictEqual(61);
+    });
+    it("bit32", () => {
+        let t = m.bit32(11);
+        expect(t).toStrictEqual(2048);
+        t = m.bit32(15);
+        expect(t).toStrictEqual(32768);
+        t = m.bit32(26);
+        expect(t).toStrictEqual(67108864);
+        t = m.bit32(11) | m.bit32(15) | m.bit32(20) | m.bit32(25);
+        expect(t).toStrictEqual(34637824);
+        t =
+            m.bit32(12) |
+            m.bit32(13) |
+            m.bit32(14) |
+            m.bit32(16) |
+            m.bit32(17) |
+            m.bit32(18) |
+            m.bit32(19) |
+            m.bit32(21) |
+            m.bit32(22) |
+            m.bit32(23) |
+            m.bit32(24) |
+            m.bit32(26);
+        expect(t).toStrictEqual(99577856);
+        t = B32 & m.bit32(0);
+        expect(t).toStrictEqual(0);
+        t = B32 & m.bit32(3);
+        expect(t).toStrictEqual(8);
+        t = B32 | m.bit32(0);
+        expect(t).toStrictEqual(-1091568945);
+        t = B32 | m.bit32(3);
+        expect(t).toStrictEqual(-1091568946);
+    });
+    it("lowHighBytes", () => {
+        let [l, h] = m.lowHighBytes(1024);
+        expect(l).toStrictEqual(0);
+        expect(h).toStrictEqual(4);
+        expect(l).toStrictEqual(m.lowByte(1024));
+        expect(h).toStrictEqual(m.highByte(1024));
+        [l, h] = m.lowHighBytes(255);
+        expect(l).toStrictEqual(255);
+        expect(h).toStrictEqual(0);
+    });
+    it("lowHighBits", () => {
+        let [l, h] = m.lowHighBits(10);
+        expect(l).toStrictEqual(10);
+        expect(h).toStrictEqual(0);
+        expect(l).toStrictEqual(m.lowBits(10));
+        expect(h).toStrictEqual(m.highBits(0));
+        [l, h] = m.lowHighBits(100);
+        expect(l).toStrictEqual(4);
+        expect(h).toStrictEqual(6);
+    });
+    it("byteToBits", () => {
+        let t = m.byteToBits(2);
+        expect(t).toStrictEqual("00000010");
+        t = m.byteToBits(4);
+        expect(t).toStrictEqual("00000100");
+    });
+});