@willieee802/zigbee-herdsman 0.48.3 → 0.49.1

package/test/benchOptions.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,431 @@
+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

@@ -0,0 +1,215 @@
+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 = () => {};
+        db.update = () => {};
+
+        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();
+            },
+        },
+    );
+});