zigbee-herdsman 6.0.1 → 6.0.3

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

@@ -1,206 +0,0 @@
-import {describe, expect, it} from "vitest";
-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");
-    });
-});

package/test/adapter/ezsp/frame.test.ts

@@ -1,30 +0,0 @@
-import {describe, expect, it} from "vitest";
-import {EZSPFrameData} from "../../../src/adapter/ezsp/driver/ezsp";
-
-describe("FRAME Parsing", () => {
-    it("changeSourceRouteHandler", () => {
-        const frm = EZSPFrameData.createFrame(8, 0x00c4, false, Buffer.from("05e399a000", "hex"));
-        expect(frm._cls_).toBe("changeSourceRouteHandler");
-        expect(frm._id_).toBe(0x00c4);
-        expect(frm.newChildId).toBe(0xe305);
-        expect(frm.newParentId).toBe(0xa099);
-    });
-    it("changeSourceRouteHandler", () => {
-        const frm = EZSPFrameData.createFrame(9, 0x00c4, false, Buffer.from("05e399a000", "hex"));
-        expect(frm._cls_).toBe("incomingNetworkStatusHandler");
-        expect(frm._id_).toBe(0x00c4);
-        expect(frm.errorCode).toBe(0x05);
-        expect(frm.target).toBe(0x99e3);
-    });
-    it("incomingNetworkStatusHandler", () => {
-        const frm = EZSPFrameData.createFrame(9, 0x00c4, false, Buffer.from("0b044e", "hex"));
-        expect(frm._cls_).toBe("incomingNetworkStatusHandler");
-        expect(frm._id_).toBe(0x00c4);
-        expect(frm.errorCode).toBe(0x0b);
-        expect(frm.target).toBe(0x4e04);
-    });
-    it("incomingNetworkStatusHandler", () => {
-        const frm = EZSPFrameData.createFrame(8, 0x00c4, false, Buffer.from("0b044e", "hex"));
-        expect(frm).toBe(undefined);
-    });
-});

package/test/adapter/ezsp/uart.test.ts

@@ -1,181 +0,0 @@
-import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
-import {FrameType} from "../../../src/adapter/ezsp/driver/frame";
-import {Parser} from "../../../src/adapter/ezsp/driver/parser";
-import {SerialDriver} from "../../../src/adapter/ezsp/driver/uart";
-import {Writer} from "../../../src/adapter/ezsp/driver/writer";
-import {SerialPort} from "../../../src/adapter/serialPort";
-
-const mockSerialPortClose = vi.fn().mockImplementation((cb) => (cb ? cb() : null));
-const mockSerialPortFlush = vi.fn().mockImplementation((cb) => cb());
-const mockSerialPortAsyncFlushAndClose = vi.fn();
-const mockSerialPortPipe = vi.fn();
-const mockSerialPortOpen = vi.fn().mockImplementation((cb) => cb());
-const mockSerialPortAsyncOpen = vi.fn();
-const mockSerialPortConstructor = vi.fn();
-const mockSerialPortOnce = vi.fn();
-const mockSerialPortSet = vi.fn().mockImplementation((_opts, cb) => cb());
-const mockSerialPortWrite = vi.fn((_buffer, cb) => (cb ? cb() : null));
-const mockSerialPortIsOpen = false;
-
-vi.mock("../../../src/adapter/serialPort", () => ({
-    SerialPort: vi.fn(() => ({
-        close: mockSerialPortClose,
-        constructor: mockSerialPortConstructor,
-        emit: () => {},
-        on: () => {},
-        once: mockSerialPortOnce,
-        open: mockSerialPortOpen,
-        pipe: mockSerialPortPipe,
-        set: mockSerialPortSet,
-        write: mockSerialPortWrite,
-        flush: mockSerialPortFlush,
-        isOpen: mockSerialPortIsOpen,
-        asyncOpen: mockSerialPortAsyncOpen,
-        asyncFlushAndClose: mockSerialPortAsyncFlushAndClose,
-    })),
-}));
-
-vi.mock("../../../src/utils/wait", () => ({
-    wait: vi.fn(() => {
-        return new Promise<void>((resolve) => resolve());
-    }),
-}));
-
-let writeBufferSpy;
-
-const mocks = [
-    mockSerialPortClose,
-    mockSerialPortPipe,
-    mockSerialPortConstructor,
-    mockSerialPortOpen,
-    mockSerialPortOnce,
-    mockSerialPortWrite,
-    SerialPort,
-    mockSerialPortAsyncFlushAndClose,
-    mockSerialPortAsyncOpen,
-];
-
-describe("UART", () => {
-    let serialDriver;
-    beforeAll(() => {
-        vi.useFakeTimers();
-    });
-
-    afterAll(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-    });
-
-    beforeEach(() => {
-        for (const mock of mocks) {
-            // @ts-ignore
-            mock.mockClear();
-        }
-
-        // @ts-ignore; make sure we always get a new instance
-        serialDriver = new SerialDriver();
-        writeBufferSpy = vi.spyOn(Writer.prototype, "writeBuffer").mockImplementation((buffer) => {
-            if (buffer[0] === 0x1a) {
-                serialDriver.waitress.resolve({sequence: -1});
-            }
-        });
-        vi.spyOn(Writer.prototype, "pipe").mockImplementation(vi.fn());
-    });
-
-    afterEach(() => {
-        writeBufferSpy.mockRestore();
-    });
-
-    it("Connect", async () => {
-        await serialDriver.connect({path: "/dev/ttyACM0"});
-
-        expect(SerialPort).toHaveBeenCalledTimes(1);
-        expect(SerialPort).toHaveBeenCalledWith({
-            path: "/dev/ttyACM0",
-            baudRate: 115200,
-            rtscts: false,
-            autoOpen: false,
-            parity: "none",
-            stopBits: 1,
-            xon: true,
-            xoff: true,
-        });
-
-        expect(mockSerialPortPipe).toHaveBeenCalledTimes(1);
-        expect(mockSerialPortAsyncOpen).toHaveBeenCalledTimes(1);
-        expect(mockSerialPortOnce).toHaveBeenCalledTimes(1);
-        expect(writeBufferSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("Send data", async () => {
-        await serialDriver.connect("/dev/ttyACM0", {});
-        // send 8 frames
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        expect(writeBufferSpy).toHaveBeenCalledTimes(2);
-        // send another 2 frame - not counted, until resolve 8 promices
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        serialDriver.sendDATA(Buffer.from([1, 2, 3]));
-        expect(writeBufferSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it("Receive data", () => {
-        const parsed = [];
-        const parser = new Parser();
-        parser.on("parsed", (result) => parsed.push(result));
-        // send 4 frames
-        const buffer0 = Buffer.from([0xc1, 0x02, 0x0b, 0x0a, 0x52, 0x7e]);
-        const buffer1 = Buffer.from([
-            0x22, 0x5b, 0xb1, 0xa9, 0x0d, 0x2a, 0xc1, 0xd8, 0x19, 0x53, 0x4a, 0x14, 0xaa, 0xe9, 0x87, 0x49, 0xfc, 0xfa, 0x26, 0x7d, 0x5e, 0xc5, 0xaa,
-            0xc8, 0x7e,
-        ]);
-        const buffer2 = Buffer.from([
-            0x32, 0x5b, 0xb1, 0xa9, 0x7d, 0x31, 0x2a, 0x15, 0xb6, 0x58, 0x8d, 0x4a, 0x06, 0xab, 0x55, 0x93, 0x49, 0x9c, 0x45, 0x7b, 0x7d, 0x38, 0x39,
-            0xa4, 0x98, 0x74, 0xf1, 0xd7, 0x26, 0x88, 0xfc, 0x6b, 0x2f, 0xf6, 0xe9, 0xc5, 0xde, 0x6b, 0x8f, 0xfb, 0xd8, 0xf9, 0x7e,
-        ]);
-        const buffer3 = Buffer.from([0xa2, 0x74, 0x58, 0x7e]);
-        parser._transform(buffer0, "", () => {});
-        parser._transform(buffer1, "", () => {});
-        parser._transform(buffer2, "", () => {});
-        parser._transform(buffer3, "", () => {});
-        expect(parsed.length).toBe(4);
-        expect(parsed[0].type).toBe(FrameType.RSTACK);
-        expect(parsed[1].type).toBe(FrameType.DATA);
-        expect(parsed[2].type).toBe(FrameType.DATA);
-        expect(parsed[3].type).toBe(FrameType.NAK);
-    });
-
-    it("Message in two chunks", () => {
-        const parsed = [];
-        const parser = new Parser();
-        parser.on("parsed", (result) => parsed.push(result));
-        const buffer1 = Buffer.from([0x22, 0x5b, 0xb1, 0xa9, 0x0d, 0x2a, 0xc1, 0xd8, 0x19, 0x53, 0x4a, 0x14]);
-        parser._transform(buffer1, "", () => {});
-        expect(parsed.length).toBe(0);
-        const buffer2 = Buffer.from([0xaa, 0xe9, 0x87, 0x49, 0xfc, 0xfa, 0x26, 0x7d, 0x5e, 0xc5, 0xaa, 0xc8, 0x7e]);
-        parser._transform(buffer2, "", () => {});
-        expect(parsed.length).toBe(1);
-        expect(parsed[0].type).toBe(FrameType.DATA);
-    });
-
-    it("Two messages in one chunk", () => {
-        const parsed = [];
-        const parser = new Parser();
-        parser.on("parsed", (result) => parsed.push(result));
-        const buffer1 = Buffer.from([
-            0x22, 0x5b, 0xb1, 0xa9, 0x0d, 0x2a, 0xc1, 0xd8, 0x19, 0x53, 0x4a, 0x14, 0xaa, 0xe9, 0x87, 0x49, 0xfc, 0xfa, 0x26, 0x7d, 0x5e, 0xc5, 0xaa,
-            0xc8, 0x7e, 0x32, 0x5b, 0xb1, 0xa9, 0x7d, 0x31, 0x2a, 0x15, 0xb6, 0x58, 0x8d, 0x4a, 0x06, 0xab, 0x55, 0x93, 0x49, 0x9c, 0x45, 0x7b, 0x7d,
-            0x38, 0x39, 0xa4, 0x98, 0x74, 0xf1, 0xd7, 0x26, 0x88, 0xfc, 0x6b, 0x2f, 0xf6, 0xe9, 0xc5, 0xde, 0x6b, 0x8f, 0xfb, 0xd8, 0xf9, 0x7e,
-        ]);
-        parser._transform(buffer1, "", () => {});
-        expect(parsed.length).toBe(2);
-        expect(parsed[0].type).toBe(FrameType.DATA);
-        expect(parsed[1].type).toBe(FrameType.DATA);
-    });
-});