zigbee-herdsman 6.0.2 → 6.0.4

package/test/benchOptions.ts

@@ -1,14 +0,0 @@
-import {hrtime} from "node:process";
-import type {bench} from "vitest";
-
-export const BENCH_OPTIONS: NonNullable<Parameters<typeof bench>[2]> = {
-    throws: true,
-    warmupTime: 1000,
-    now: () => Number(hrtime.bigint()) / 1e6,
-    setup: (_task, mode) => {
-        // Run the garbage collector before warmup at each cycle
-        if (mode === "warmup" && typeof globalThis.gc === "function") {
-            globalThis.gc();
-        }
-    },
-};

package/test/buffalo.test.ts

@@ -1,431 +0,0 @@
-import {describe, expect, it} from "vitest";
-import {Buffalo} from "../src/buffalo";
-import {ieeeaAddr1, ieeeaAddr2} from "./testUtils";
-
-describe("Buffalo", () => {
-    it("is more", () => {
-        const buffalo = new Buffalo(Buffer.from([0, 1, 2]), 1);
-        expect(buffalo.getPosition()).toEqual(1);
-        expect(buffalo.isMore()).toStrictEqual(true);
-        buffalo.readUInt16();
-        expect(buffalo.isMore()).toStrictEqual(false);
-    });
-
-    it("gets written", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3), 1);
-        buffalo.writeUInt8(240);
-        expect(buffalo.getWritten()).toStrictEqual(Buffer.from([0, 240]));
-    });
-
-    it("UINT8 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3), 1);
-        buffalo.writeUInt8(240);
-        expect(buffalo.getPosition()).toEqual(2);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0xf0, 0x00]));
-    });
-
-    it("UINT8 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x03, 0x00, 0x00]), 1);
-        const value = buffalo.readUInt8();
-        expect(buffalo.getPosition()).toEqual(2);
-        expect(value).toStrictEqual(3);
-    });
-
-    it("INT8 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3), 1);
-        buffalo.writeInt8(127);
-        expect(buffalo.getPosition()).toEqual(2);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x7f, 0x00]));
-    });
-
-    it("INT8 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0xf0, 0x00, 0x00]), 1);
-        const value = buffalo.readInt8();
-        expect(buffalo.getPosition()).toEqual(2);
-        expect(value).toStrictEqual(-16);
-    });
-
-    it("INT16 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3), 1);
-        buffalo.writeInt16(256);
-        expect(buffalo.getPosition()).toEqual(3);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x00, 0x01]));
-    });
-
-    it("INT16 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0xff, 0xff, 0x00]), 1);
-        const value = buffalo.readInt16();
-        expect(buffalo.getPosition()).toEqual(3);
-        expect(value).toStrictEqual(-1);
-    });
-
-    it("UINT16 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3), 1);
-        buffalo.writeUInt16(1020);
-        expect(buffalo.getPosition()).toEqual(3);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0xfc, 0x03]));
-    });
-
-    it("UINT16 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x03, 0xff, 0x00]), 1);
-        const value = buffalo.readUInt16();
-        expect(buffalo.getPosition()).toEqual(3);
-        expect(value).toStrictEqual(65283);
-    });
-
-    it("INT32 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(6), 2);
-        buffalo.writeInt32(1065283);
-        expect(buffalo.getPosition()).toEqual(6);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x00, 0x43, 0x41, 0x10, 0x00]));
-    });
-
-    it("INT32 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x01, 0x03, 0xff, 0xff]));
-        const value = buffalo.readInt32();
-        expect(buffalo.getPosition()).toEqual(4);
-        expect(value).toStrictEqual(-64767);
-    });
-
-    it("UINT32 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(6), 2);
-        buffalo.writeUInt32(1065283);
-        expect(buffalo.getPosition()).toEqual(6);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x00, 0x43, 0x41, 0x10, 0x00]));
-    });
-
-    it("UINT32 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x01, 0x03, 0xff, 0xff]));
-        const value = buffalo.readUInt32();
-        expect(buffalo.getPosition()).toEqual(4);
-        expect(value).toStrictEqual(4294902529);
-    });
-
-    it("INT40 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(7), 2);
-        buffalo.writeInt40(21542142465);
-        expect(buffalo.getPosition()).toEqual(7);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 1, 2, 3, 4, 5]));
-    });
-
-    it("INT40 read", () => {
-        const buffalo = new Buffalo(Buffer.from([1, 2, 3, 4, 5]));
-        const value = buffalo.readInt40();
-        expect(buffalo.getPosition()).toEqual(5);
-        expect(value).toStrictEqual(21542142465);
-    });
-
-    it("UINT40 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(7), 2);
-        buffalo.writeUInt40(21542142465);
-        expect(buffalo.getPosition()).toEqual(7);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 1, 2, 3, 4, 5]));
-    });
-
-    it("UINT40 read", () => {
-        const buffalo = new Buffalo(Buffer.from([1, 2, 3, 4, 5]));
-        const value = buffalo.readUInt40();
-        expect(buffalo.getPosition()).toEqual(5);
-        expect(value).toStrictEqual(21542142465);
-    });
-
-    it("INT48 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(8), 2);
-        buffalo.writeInt48(6618611909121);
-        expect(buffalo.getPosition()).toEqual(8);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 1, 2, 3, 4, 5, 6]));
-    });
-
-    it("INT48 read", () => {
-        const buffalo = new Buffalo(Buffer.from([1, 2, 3, 4, 5, 6]));
-        const value = buffalo.readInt48();
-        expect(buffalo.getPosition()).toEqual(6);
-        expect(value).toStrictEqual(6618611909121);
-    });
-
-    it("UINT48 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(8), 2);
-        buffalo.writeUInt48(6618611909121);
-        expect(buffalo.getPosition()).toEqual(8);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 1, 2, 3, 4, 5, 6]));
-    });
-
-    it("UINT48 read", () => {
-        const buffalo = new Buffalo(Buffer.from([1, 2, 3, 4, 5, 6]));
-        const value = buffalo.readUInt48();
-        expect(buffalo.getPosition()).toEqual(6);
-        expect(value).toStrictEqual(6618611909121);
-    });
-
-    it("UINT56 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(9), 2);
-        buffalo.writeUInt56(72057594037927934n);
-        expect(buffalo.getPosition()).toEqual(9);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 254, 255, 255, 255, 255, 255, 255]));
-    });
-
-    it("UINT56 read", () => {
-        const buffalo = new Buffalo(Buffer.from([254, 255, 255, 255, 255, 255, 255]));
-        const value = buffalo.readUInt56();
-        expect(buffalo.getPosition()).toEqual(7);
-        expect(value).toStrictEqual(72057594037927934n);
-    });
-
-    it.each([
-        [36028797018963964n, [0, 0, 252, 255, 255, 255, 255, 255, 127]],
-        [-36028797018963964n, [0, 0, 4, 0, 0, 0, 0, 0, 128]],
-    ])("INT56 write", (value: bigint, expectedValues: number[]) => {
-        const buffalo = new Buffalo(Buffer.alloc(9), 2);
-        buffalo.writeInt56(value);
-        expect(buffalo.getPosition()).toEqual(9);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from(expectedValues));
-    });
-
-    it.each([
-        [36028797018963964n, [252, 255, 255, 255, 255, 255, 127]],
-        [-36028797018963964n, [4, 0, 0, 0, 0, 0, 128]],
-    ])("INT56 read", (expectedValue: bigint, values: number[]) => {
-        const buffalo = new Buffalo(Buffer.from(values));
-        const value = buffalo.readInt56();
-        expect(buffalo.getPosition()).toEqual(7);
-        expect(value).toStrictEqual(expectedValue);
-    });
-
-    it("UINT64 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(10), 2);
-        buffalo.writeUInt64(18446744073709551613n);
-        expect(buffalo.getPosition()).toEqual(10);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 253, 255, 255, 255, 255, 255, 255, 255]));
-    });
-
-    it("UINT64 read", () => {
-        const buffalo = new Buffalo(Buffer.from([253, 255, 255, 255, 255, 255, 255, 255]));
-        const value = buffalo.readUInt64();
-        expect(buffalo.getPosition()).toEqual(8);
-        expect(value).toStrictEqual(18446744073709551613n);
-    });
-
-    it("INT64 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(10), 2);
-        buffalo.writeInt64(9223372036854775806n);
-        expect(buffalo.getPosition()).toEqual(10);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0, 0, 254, 255, 255, 255, 255, 255, 255, 127]));
-    });
-
-    it("INT64 read", () => {
-        const buffalo = new Buffalo(Buffer.from([254, 255, 255, 255, 255, 255, 255, 127]));
-        const value = buffalo.readInt64();
-        expect(buffalo.getPosition()).toEqual(8);
-        expect(value).toStrictEqual(9223372036854775806n);
-    });
-
-    it("IEEEADDR write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(8));
-        buffalo.writeIeeeAddr(ieeeaAddr1.string);
-        expect(buffalo.getPosition()).toEqual(8);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from(ieeeaAddr1.hex));
-    });
-
-    it("IEEEADDR read", () => {
-        const buffalo = new Buffalo(Buffer.from(ieeeaAddr2.hex));
-        const value = buffalo.readIeeeAddr();
-        expect(buffalo.getPosition()).toEqual(8);
-        expect(value).toStrictEqual(ieeeaAddr2.string);
-    });
-
-    it("BUFFER write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(5), 1);
-        const payload = Buffer.from([0x00, 0x01, 0x02]);
-        buffalo.writeBuffer(payload, payload.length);
-        expect(buffalo.getPosition()).toEqual(4);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, ...payload, 0x00]));
-    });
-
-    it("BUFFER write as array", () => {
-        const buffalo = new Buffalo(Buffer.alloc(5), 1);
-        const payload = [0x00, 0x01, 0x02];
-        buffalo.writeBuffer(payload, payload.length);
-        expect(buffalo.getPosition()).toEqual(4);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, ...payload, 0x00]));
-    });
-
-    it("BUFFER read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09]), 2);
-        const value = buffalo.readBuffer(5);
-        expect(buffalo.getPosition()).toEqual(7);
-        expect(value).toStrictEqual(Buffer.from([0x02, 0x03, 0x04, 0x05, 0x06]));
-    });
-
-    it("LIST_UINT8 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(4), 1);
-        const payload = [200, 100];
-        buffalo.writeListUInt8(payload);
-        expect(buffalo.getPosition()).toStrictEqual(3);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0xc8, 0x64, 0x00]));
-    });
-
-    it("LIST_UINT8 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x00, 0x04, 0x08]), 2);
-        const value = buffalo.readListUInt8(2);
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(value).toStrictEqual([4, 8]);
-    });
-
-    it("LIST_UINT16 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(5), 1);
-        const payload = [1024, 2048];
-        buffalo.writeListUInt16(payload);
-        expect(buffalo.getPosition()).toStrictEqual(5);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x00, 0x04, 0x00, 0x08]));
-    });
-
-    it("LIST_UINT16 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x00, 0x04, 0x00, 0x08]), 1);
-        const value = buffalo.readListUInt16(2);
-        expect(buffalo.getPosition()).toStrictEqual(5);
-        expect(value).toStrictEqual([1024, 2048]);
-    });
-
-    it("LIST_UINT24 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(8), 1);
-        const payload = [100000, 110110];
-        buffalo.writeListUInt24(payload);
-        expect(buffalo.getPosition()).toStrictEqual(7);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0xa0, 0x86, 0x01, 0x1e, 0xae, 0x01, 0x00]));
-    });
-
-    it("LIST_UINT24 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0xa0, 0x86, 0x01, 0x1e, 0xae, 0x01, 0x00]), 1);
-        const value = buffalo.readListUInt24(2);
-        expect(buffalo.getPosition()).toStrictEqual(7);
-        expect(value).toStrictEqual([100000, 110110]);
-    });
-
-    it("LIST_UINT32 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(8));
-        const payload = [4294967295, 10];
-        buffalo.writeListUInt32(payload);
-        expect(buffalo.getPosition()).toStrictEqual(8);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00]));
-    });
-
-    it("LIST_UINT32 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00]));
-        const value = buffalo.readListUInt32(2);
-        expect(buffalo.getPosition()).toStrictEqual(8);
-        expect(value).toStrictEqual([4294967295, 10]);
-    });
-
-    it("UINT24 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(4), 1);
-        const payload = 16777200;
-        buffalo.writeUInt24(payload);
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0xf0, 0xff, 0xff]));
-    });
-
-    it("UINT24 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x01, 0xa0, 0x86, 0x01, 0x02]), 1);
-        const value = buffalo.readUInt24();
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(value).toStrictEqual(100000);
-    });
-
-    it("INT24 write +", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3));
-        buffalo.writeInt24(65536);
-        expect(buffalo.getPosition()).toStrictEqual(3);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x00, 0x01]));
-    });
-
-    it("INT24 read +", () => {
-        const buffalo = new Buffalo(Buffer.from([0x7f, 0xff, 0xff, 0x7f]), 1);
-        const value = buffalo.readInt24();
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(value).toStrictEqual(8388607);
-    });
-
-    it("INT24 write -", () => {
-        const buffalo = new Buffalo(Buffer.alloc(3));
-        buffalo.writeInt24(-65536);
-        expect(buffalo.getPosition()).toStrictEqual(3);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x00, 0xff]));
-    });
-
-    it("INT24 read -", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x00, 0xff]));
-        const value = buffalo.readInt24();
-        expect(buffalo.getPosition()).toStrictEqual(3);
-        expect(value).toStrictEqual(-65536);
-    });
-
-    it("INT32 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(4));
-        buffalo.writeInt32(2147483647);
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0xff, 0xff, 0xff, 0x7f]));
-    });
-
-    it("INT32 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x08, 0xff, 0x03, 0xff]));
-        const value = buffalo.readInt32();
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(value).toStrictEqual(-16515320);
-    });
-
-    it("INT48 write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(6));
-        buffalo.writeInt48(-1082348273920);
-        expect(buffalo.getPosition()).toStrictEqual(6);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0xff, 0x03, 0xff, 0x03, 0xff]));
-    });
-
-    it("INT48 read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0xff, 0x03, 0xff, 0x03, 0xff]));
-        const value = buffalo.readInt48();
-        expect(buffalo.getPosition()).toStrictEqual(6);
-        expect(value).toStrictEqual(-1082348273920);
-    });
-
-    it("FLOATLE write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(4));
-        buffalo.writeFloatLE(400.5);
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x00, 0x40, 0xc8, 0x43]));
-    });
-
-    it("FLOATLE read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x00, 0x40, 0xc8, 0x43]));
-        const value = buffalo.readFloatLE();
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(value).toStrictEqual(400.5);
-    });
-
-    it("DOUBLELE write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(8));
-        buffalo.writeDoubleLE(809880.6);
-        expect(buffalo.getPosition()).toStrictEqual(8);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x33, 0x33, 0x33, 0x33, 0x31, 0xb7, 0x28, 0x41]));
-    });
-
-    it("DOUBLELE read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x33, 0x33, 0x33, 0x33, 0x31, 0xb7, 0x28, 0x41]), 0);
-        const value = buffalo.readDoubleLE();
-        expect(buffalo.getPosition()).toStrictEqual(8);
-        expect(value).toStrictEqual(809880.6);
-    });
-
-    it("UTF8 STRING write", () => {
-        const buffalo = new Buffalo(Buffer.alloc(4));
-        buffalo.writeUtf8String("abcd");
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(buffalo.getBuffer()).toStrictEqual(Buffer.from([0x61, 0x62, 0x63, 0x64]));
-    });
-
-    it("UTF8 STRING read", () => {
-        const buffalo = new Buffalo(Buffer.from([0x61, 0x62, 0x63, 0x64]), 0);
-        const value = buffalo.readUtf8String(4);
-        expect(buffalo.getPosition()).toStrictEqual(4);
-        expect(value).toStrictEqual("abcd");
-    });
-});

package/test/controller.bench.ts

@@ -1,214 +0,0 @@
-import {bench, describe} from "vitest";
-import Adapter from "../src/adapter/adapter";
-import {FIXED_ENDPOINTS} from "../src/adapter/ember/adapter/endpoints";
-import type {ZclPayload} from "../src/adapter/events";
-import {Controller} from "../src/controller";
-import Database from "../src/controller/database";
-import {setLogger} from "../src/utils/logger";
-import * as Zcl from "../src/zspec/zcl";
-import * as Zdo from "../src/zspec/zdo";
-import {BENCH_OPTIONS} from "./benchOptions";
-
-// mock necessary functions to avoid system calls / adapter interactions
-
-// no-op, makes up for too much of the perf loss (with console logging by default)
-setLogger({
-    debug: () => {},
-    info: () => {},
-    warning: () => {},
-    error: () => {},
-});
-
-const NETWORK_OPTIONS = {
-    panID: 0x1a62,
-    extendedPanID: [0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd],
-    channelList: [11],
-    networkKey: [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13],
-    // networkKeyDistribute?: boolean;
-};
-const COORD_IEEE = "0x1234567812345678";
-
-let controller: Controller;
-let adapter: Adapter;
-
-const makeController = () => {
-    controller = new Controller({
-        network: NETWORK_OPTIONS,
-        serialPort: {
-            baudRate: 115200,
-            rtscts: false,
-            path: "/dev/ttyDummy0",
-            adapter: "ember",
-        },
-        databasePath: "database.db",
-        databaseBackupPath: "database.db.backup",
-        backupPath: "coordinator_backup.json",
-        adapter: {
-            // concurrent?: number;
-            // delay?: number;
-            disableLED: false,
-            // transmitPower?: number;
-            // forceStartWithInconsistentAdapterConfiguration?: boolean;
-        },
-        acceptJoiningDeviceHandler: async () => true,
-    });
-    controller.backup = async () => {};
-
-    const dbOpen = Database.open;
-    Database.open = (path) => {
-        const db = dbOpen(path);
-        // no-op
-        db.write = () => {};
-
-        return db;
-    };
-    const adapterCreate = Adapter.create;
-    Adapter.create = async (networkOptions, serialPortOptions, backupPath, adapterOptions) => {
-        adapter = await adapterCreate(networkOptions, serialPortOptions, backupPath, adapterOptions);
-        adapter.start = async () => await Promise.resolve("resumed");
-        adapter.getCoordinatorIEEE = async () => await Promise.resolve(COORD_IEEE);
-        adapter.getNetworkParameters = async () =>
-            await Promise.resolve({
-                panID: NETWORK_OPTIONS.panID,
-                extendedPanID: `${Buffer.from(NETWORK_OPTIONS.extendedPanID!).toString("hex")}`,
-                channel: NETWORK_OPTIONS.channelList[0],
-                nwkUpdateID: 1,
-            });
-        // @ts-expect-error ignore overrides typing
-        adapter.sendZdo = async (
-            _ieeeAddress: string,
-            networkAddress: number,
-            clusterId: Zdo.ClusterId,
-            payload: Buffer,
-            _disableResponse: boolean,
-        ) => {
-            if (networkAddress === 0x0000) {
-                switch (clusterId) {
-                    case Zdo.ClusterId.ACTIVE_ENDPOINTS_REQUEST: {
-                        return await Promise.resolve([
-                            Zdo.Status.SUCCESS,
-                            {
-                                nwkAddress: 0x0000,
-                                endpointList: [FIXED_ENDPOINTS[0].endpoint, FIXED_ENDPOINTS[1].endpoint],
-                            },
-                        ]);
-                    }
-                    case Zdo.ClusterId.SIMPLE_DESCRIPTOR_REQUEST: {
-                        if (payload.readUInt8(3) === FIXED_ENDPOINTS[0].endpoint) {
-                            return await Promise.resolve([
-                                Zdo.Status.SUCCESS,
-                                {
-                                    nwkAddress: 0x0000,
-                                    length: 1, // unused
-                                    ...FIXED_ENDPOINTS[0],
-                                },
-                            ]);
-                        }
-
-                        if (payload.readUInt8(3) === FIXED_ENDPOINTS[1].endpoint) {
-                            return await Promise.resolve([
-                                Zdo.Status.SUCCESS,
-                                {
-                                    nwkAddress: 0x0000,
-                                    length: 1, // unused
-                                    ...FIXED_ENDPOINTS[1],
-                                },
-                            ]);
-                        }
-                    }
-                }
-            }
-
-            return await Promise.resolve([Zdo.Status.NOT_SUPPORTED]);
-        };
-
-        return adapter;
-    };
-
-    return controller;
-};
-
-const BASIC_RESP = Zcl.Frame.create(
-    0,
-    1,
-    true,
-    undefined,
-    10,
-    "readRsp",
-    0,
-    [
-        {
-            attrId: 5,
-            dataType: Zcl.DataType.CHAR_STR,
-            attrData: "Herd-01",
-            status: 0,
-        },
-        {
-            attrId: 4,
-            dataType: Zcl.DataType.CHAR_STR,
-            attrData: "Herdsman",
-            status: 0,
-        },
-    ],
-    {},
-).toBuffer();
-
-describe("Controller", () => {
-    bench(
-        "Startup with dummy adapter",
-        async () => {
-            makeController(); // always use brand new Controller for this bench
-
-            await controller.start();
-        },
-        BENCH_OPTIONS,
-    );
-
-    bench(
-        "Receive ZCL message",
-        () => {
-            adapter.emit("zclPayload", {
-                clusterID: Zcl.Clusters.genBasic.ID,
-                header: Zcl.Header.fromBuffer(BASIC_RESP),
-                address: 0x0000,
-                data: BASIC_RESP,
-                endpoint: 1,
-                linkquality: 200,
-                groupID: 0,
-                wasBroadcast: false,
-                destinationEndpoint: 1,
-            } satisfies ZclPayload);
-        },
-        {
-            ...BENCH_OPTIONS,
-            setup: async (task, mode) => {
-                await BENCH_OPTIONS.setup!(task, mode);
-                makeController();
-                await controller.start();
-            },
-        },
-    );
-
-    bench(
-        "Receive ZDO message",
-        () => {
-            adapter.emit("zdoResponse", Zdo.ClusterId.NETWORK_ADDRESS_RESPONSE, [
-                Zdo.Status.SUCCESS,
-                {
-                    eui64: COORD_IEEE,
-                    nwkAddress: 0x0000,
-                    startIndex: 1,
-                    assocDevList: [],
-                },
-            ]);
-        },
-        {
-            ...BENCH_OPTIONS,
-            setup: async (task, mode) => {
-                await BENCH_OPTIONS.setup!(task, mode);
-                makeController();
-                await controller.start();
-            },
-        },
-    );
-});