@willieee802/zigbee-herdsman 0.48.2 → 0.49.0

package/test/adapter/ember/emberAdapter.test.ts

@@ -0,0 +1,3447 @@
+import {existsSync, mkdirSync, unlinkSync, writeFileSync} from "node:fs";
+import path from "node:path";
+import {EventEmitter} from "node:stream";
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+import type {TsType} from "../../../src/adapter";
+import {
+    DEFAULT_APS_OPTIONS,
+    DEFAULT_STACK_CONFIG,
+    EmberAdapter,
+    type LinkKeyBackupData,
+    type NetworkCache,
+} from "../../../src/adapter/ember/adapter/emberAdapter";
+import {FIXED_ENDPOINTS} from "../../../src/adapter/ember/adapter/endpoints";
+import {OneWaitressEvents} from "../../../src/adapter/ember/adapter/oneWaitress";
+import {EMBER_LOW_RAM_CONCENTRATOR, SECURITY_LEVEL_Z3} from "../../../src/adapter/ember/consts";
+import {
+    EmberApsOption,
+    EmberDeviceUpdate,
+    EmberIncomingMessageType,
+    EmberJoinDecision,
+    EmberJoinMethod,
+    EmberKeyStructBitmask,
+    EmberNetworkStatus,
+    EmberNodeType,
+    EmberOutgoingMessageType,
+    EmberVersionType,
+    EzspStatus,
+    IEEE802154CcaMode,
+    SecManDerivedKeyType,
+    SecManFlag,
+    SecManKeyType,
+    SLStatus,
+} from "../../../src/adapter/ember/enums";
+import {EZSP_MIN_PROTOCOL_VERSION, EZSP_PROTOCOL_VERSION, EZSP_STACK_TYPE_MESH} from "../../../src/adapter/ember/ezsp/consts";
+import {EzspConfigId, EzspDecisionBitmask, EzspEndpointFlag, EzspPolicyId, EzspValueId} from "../../../src/adapter/ember/ezsp/enums";
+import type {EmberEzspEventMap} from "../../../src/adapter/ember/ezsp/ezsp";
+import {EzspError} from "../../../src/adapter/ember/ezspError";
+import type {
+    EmberApsFrame,
+    EmberMulticastTableEntry,
+    EmberNetworkInitStruct,
+    EmberNetworkParameters,
+    EmberVersion,
+    SecManAPSKeyMetadata,
+    SecManContext,
+    SecManKey,
+    SecManNetworkKeyInfo,
+} from "../../../src/adapter/ember/types";
+import {lowHighBytes} from "../../../src/adapter/ember/utils/math";
+import type {DeviceJoinedPayload, DeviceLeavePayload, ZclPayload} from "../../../src/adapter/events";
+import type {AdapterOptions, NetworkOptions, SerialPortOptions} from "../../../src/adapter/tstype";
+import type {Backup} from "../../../src/models/backup";
+import type {UnifiedBackupStorage} from "../../../src/models/backup-storage-unified";
+import {logger} from "../../../src/utils/logger";
+import * as ZSpec from "../../../src/zspec";
+import type {Eui64, NodeId, PanId} from "../../../src/zspec/tstypes";
+import * as Zcl from "../../../src/zspec/zcl";
+import * as Zdo from "../../../src/zspec/zdo";
+import type * as ZdoTypes from "../../../src/zspec/zdo/definition/tstypes";
+
+// https://github.com/jestjs/jest/issues/6028#issuecomment-567669082
+function defuseRejection<T>(promise: Promise<T>) {
+    promise.catch(() => {});
+
+    return promise;
+}
+
+function deepClone<T>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+function reverseApsFrame(apsFrame: EmberApsFrame): EmberApsFrame {
+    return Object.assign({}, apsFrame, {sourceEndpoint: apsFrame.destinationEndpoint, destinationEndpoint: apsFrame.sourceEndpoint});
+}
+
+async function flushPromises(): Promise<void> {
+    const {setImmediate} = await vi.importActual<typeof import("node:timers")>("node:timers");
+    return new Promise(setImmediate);
+}
+
+const TEMP_PATH = path.resolve("temp");
+const STACK_CONFIG_PATH = path.join(TEMP_PATH, "stack_config.json");
+const DEFAULT_NETWORK_OPTIONS: Readonly<NetworkOptions> = {
+    panID: 24404,
+    extendedPanID: [118, 185, 136, 236, 199, 244, 246, 85],
+    channelList: [20],
+    networkKey: [72, 97, 39, 230, 92, 72, 101, 148, 64, 225, 250, 214, 195, 31, 105, 71],
+    networkKeyDistribute: false,
+};
+const DEFAULT_SERIAL_PORT_OPTIONS: Readonly<SerialPortOptions> = {
+    baudRate: 115200,
+    rtscts: false,
+    path: "MOCK",
+    adapter: "ember",
+};
+const DEFAULT_ADAPTER_OPTIONS: Readonly<AdapterOptions> = {
+    concurrent: 16,
+    disableLED: false,
+};
+const DEFAULT_BACKUP: Readonly<UnifiedBackupStorage> = {
+    metadata: {
+        format: "zigpy/open-coordinator-backup",
+        version: 1,
+        source: "zigbee-herdsman@0.55.0",
+        internal: {
+            date: "2024-07-19T15:57:15.163Z",
+            ezspVersion: 13,
+        },
+    },
+    stack_specific: {
+        ezsp: {
+            hashed_tclk: "da85e5bac80c8a958b14d44f14c2ba16",
+        },
+    },
+    coordinator_ieee: "1122334455667788",
+    pan_id: "5f54",
+    extended_pan_id: "76b988ecc7f4f655",
+    nwk_update_id: 0,
+    security_level: 5,
+    channel: 20,
+    channel_mask: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26],
+    network_key: {
+        key: "486127e65c48659440e1fad6c31f6947",
+        sequence_number: 0,
+        frame_counter: 16434,
+    },
+    devices: [],
+};
+const DEFAULT_COORDINATOR_IEEE: Eui64 = ZSpec.Utils.eui64LEBufferToHex(Buffer.from(DEFAULT_BACKUP.coordinator_ieee, "hex"));
+const DEFAULT_ADAPTER_NETWORK_PARAMETERS: EmberNetworkParameters = {
+    extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+    panId: DEFAULT_NETWORK_OPTIONS.panID,
+    radioTxPower: 5,
+    radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+    joinMethod: 0,
+    nwkManagerId: 0,
+    nwkUpdateId: 0,
+    channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+};
+
+let mockManufCode = Zcl.ManufacturerCode.SILICON_LABORATORIES;
+let mockAPSSequence = -1; // start at 0
+let mockMessageTag = -1; // start at 0
+let mockEzspEmitter = new EventEmitter<EmberEzspEventMap>();
+const mockEzspRemoveAllListeners = vi.fn().mockImplementation((e) => {
+    mockEzspEmitter.removeAllListeners(e);
+});
+const mockEzspOn = vi.fn().mockImplementation((e, l) => {
+    mockEzspEmitter.on(e, l);
+});
+const mockEzspOnce = vi.fn().mockImplementation((e, l) => {
+    mockEzspEmitter.once(e, l);
+});
+const mockEzspStart = vi.fn().mockResolvedValue(EzspStatus.SUCCESS);
+const mockEzspStop = vi.fn();
+
+const mockEzspSend = vi.fn().mockResolvedValue([SLStatus.OK, ++mockMessageTag]);
+const mockEzspSetMulticastTableEntry = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetManufacturerCode = vi.fn().mockImplementation((code) => {
+    mockManufCode = code;
+});
+const mockEzspReadAndClearCounters = vi.fn().mockResolvedValue([1, 2, 3, 4]); // not matching EmberCounterType, but doesn't matter here
+const mockEzspGetNetworkParameters = vi
+    .fn()
+    .mockResolvedValue([SLStatus.OK, EmberNodeType.COORDINATOR, deepClone(DEFAULT_ADAPTER_NETWORK_PARAMETERS)]);
+const mockEzspNetworkState = vi.fn().mockResolvedValue(EmberNetworkStatus.JOINED_NETWORK);
+const mockEzspGetEui64 = vi.fn().mockResolvedValue(DEFAULT_COORDINATOR_IEEE);
+const mockEzspSetConcentrator = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetSourceRouteDiscoveryMode = vi.fn().mockResolvedValue(1240 /* ms */);
+const mockEzspSetRadioIeee802154CcaMode = vi.fn().mockResolvedValue(SLStatus.OK);
+// not OK by default since used to detected unreged EP
+const mockEzspGetEndpointFlags = vi.fn().mockResolvedValue([SLStatus.NOT_FOUND, EzspEndpointFlag.DISABLED]);
+const mockEzspAddEndpoint = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspNetworkInit = vi.fn().mockImplementation((_networkInitStruct: EmberNetworkInitStruct) => {
+    setTimeout(async () => {
+        mockEzspEmitter.emit("stackStatus", SLStatus.NETWORK_UP);
+        await flushPromises();
+    }, 300);
+
+    return SLStatus.OK;
+});
+const mockEzspExportKey = vi.fn().mockImplementation((context: SecManContext) => {
+    switch (context.coreKeyType) {
+        case SecManKeyType.NETWORK: {
+            return [SLStatus.OK, {contents: Buffer.from(DEFAULT_BACKUP.network_key.key, "hex")} as SecManKey];
+        }
+        case SecManKeyType.TC_LINK: {
+            return [SLStatus.OK, {contents: Buffer.from(DEFAULT_BACKUP.stack_specific!.ezsp!.hashed_tclk!, "hex")} as SecManKey];
+        }
+    }
+});
+const mockEzspLeaveNetwork = vi.fn().mockImplementation(() => {
+    setTimeout(async () => {
+        mockEzspEmitter.emit("stackStatus", SLStatus.NETWORK_DOWN);
+        await flushPromises();
+    }, 300);
+
+    return SLStatus.OK;
+});
+const mockEzspSetInitialSecurityState = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetExtendedSecurityBitmask = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspClearKeyTable = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspFormNetwork = vi.fn().mockImplementation((_parameters: EmberNetworkParameters) => {
+    setTimeout(async () => {
+        mockEzspEmitter.emit("stackStatus", SLStatus.NETWORK_UP);
+        await flushPromises();
+    }, 300);
+
+    return SLStatus.OK;
+});
+const mockEzspStartWritingStackTokens = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspGetConfigurationValue = vi.fn().mockImplementation((config: EzspConfigId) => {
+    switch (config) {
+        case EzspConfigId.KEY_TABLE_SIZE: {
+            return [SLStatus.OK, 0];
+        }
+    }
+});
+const mockEzspExportLinkKeyByIndex = vi.fn();
+const mockEzspEraseKeyTableEntry = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspImportLinkKey = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspBroadcastNextNetworkKey = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspBroadcastNetworkKeySwitch = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspStartScan = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspVersion = vi.fn().mockImplementation((version: number) => [version, EZSP_STACK_TYPE_MESH, 0]);
+const mockEzspSetProtocolVersion = vi.fn();
+const mockEzspGetVersionStruct = vi.fn().mockResolvedValue([
+    SLStatus.OK,
+    {
+        build: 135,
+        major: 8,
+        minor: 0,
+        patch: 0,
+        special: 0,
+        type: EmberVersionType.GA,
+    } as EmberVersion,
+]);
+const mockEzspSetConfigurationValue = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetValue = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetPolicy = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspPermitJoining = vi.fn().mockImplementation((duration: number) => {
+    setTimeout(async () => {
+        mockEzspEmitter.emit("stackStatus", duration > 0 ? SLStatus.ZIGBEE_NETWORK_OPENED : SLStatus.ZIGBEE_NETWORK_CLOSED);
+        await flushPromises();
+    }, 300);
+
+    return SLStatus.OK;
+});
+const mockEzspSendBroadcast = vi.fn().mockResolvedValue([SLStatus.OK, ++mockAPSSequence]);
+const mockEzspSendUnicast = vi.fn().mockResolvedValue([SLStatus.OK, ++mockAPSSequence]);
+const mockEzspGetNetworkKeyInfo = vi.fn().mockResolvedValue([
+    SLStatus.OK,
+    {
+        networkKeySet: true,
+        alternateNetworkKeySet: false,
+        networkKeySequenceNumber: DEFAULT_BACKUP.network_key.sequence_number,
+        altNetworkKeySequenceNumber: 0,
+        networkKeyFrameCounter: DEFAULT_BACKUP.network_key.frame_counter,
+    } as SecManNetworkKeyInfo,
+]);
+const mockEzspGetApsKeyInfo = vi.fn().mockResolvedValue([
+    SLStatus.OK,
+    {
+        bitmask: EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+        outgoingFrameCounter: 456,
+        incomingFrameCounter: 0,
+        ttlInSeconds: 0,
+    } as SecManAPSKeyMetadata,
+]);
+const mockEzspSetRadioPower = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspImportTransientKey = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspClearTransientLinkKeys = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetLogicalAndRadioChannel = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSendRawMessage = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetNWKFrameCounter = vi.fn().mockResolvedValue(SLStatus.OK);
+const mockEzspSetAPSFrameCounter = vi.fn().mockResolvedValue(SLStatus.OK);
+
+vi.mock("../../../src/adapter/ember/uart/ash");
+
+vi.mock("../../../src/adapter/ember/ezsp/ezsp", async (importOriginal) => ({
+    ...(await importOriginal()),
+    Ezsp: vi.fn(() => ({
+        removeAllListeners: mockEzspRemoveAllListeners,
+        on: mockEzspOn,
+        once: mockEzspOnce,
+
+        // only functions called from adapter
+        ash: {readAndClearCounters: vi.fn().mockReturnValue([9, 8, 7])},
+
+        start: mockEzspStart,
+        stop: mockEzspStop,
+        send: mockEzspSend,
+        ezspSetMulticastTableEntry: mockEzspSetMulticastTableEntry,
+        ezspSetManufacturerCode: mockEzspSetManufacturerCode,
+        ezspReadAndClearCounters: mockEzspReadAndClearCounters,
+        ezspGetNetworkParameters: mockEzspGetNetworkParameters,
+        ezspNetworkState: mockEzspNetworkState,
+        ezspGetEui64: mockEzspGetEui64,
+        ezspSetConcentrator: mockEzspSetConcentrator,
+        ezspSetSourceRouteDiscoveryMode: mockEzspSetSourceRouteDiscoveryMode,
+        ezspSetRadioIeee802154CcaMode: mockEzspSetRadioIeee802154CcaMode,
+        ezspGetEndpointFlags: mockEzspGetEndpointFlags,
+        ezspAddEndpoint: mockEzspAddEndpoint,
+        ezspNetworkInit: mockEzspNetworkInit,
+        ezspExportKey: mockEzspExportKey,
+        ezspLeaveNetwork: mockEzspLeaveNetwork,
+        ezspSetInitialSecurityState: mockEzspSetInitialSecurityState,
+        ezspSetExtendedSecurityBitmask: mockEzspSetExtendedSecurityBitmask,
+        ezspClearKeyTable: mockEzspClearKeyTable,
+        ezspFormNetwork: mockEzspFormNetwork,
+        ezspStartWritingStackTokens: mockEzspStartWritingStackTokens,
+        ezspGetConfigurationValue: mockEzspGetConfigurationValue,
+        ezspExportLinkKeyByIndex: mockEzspExportLinkKeyByIndex,
+        ezspEraseKeyTableEntry: mockEzspEraseKeyTableEntry,
+        ezspImportLinkKey: mockEzspImportLinkKey,
+        ezspBroadcastNextNetworkKey: mockEzspBroadcastNextNetworkKey,
+        ezspBroadcastNetworkKeySwitch: mockEzspBroadcastNetworkKeySwitch,
+        ezspStartScan: mockEzspStartScan,
+        ezspVersion: mockEzspVersion,
+        setProtocolVersion: mockEzspSetProtocolVersion,
+        ezspGetVersionStruct: mockEzspGetVersionStruct,
+        ezspSetConfigurationValue: mockEzspSetConfigurationValue,
+        ezspSetValue: mockEzspSetValue,
+        ezspSetPolicy: mockEzspSetPolicy,
+        ezspPermitJoining: mockEzspPermitJoining,
+        ezspSendBroadcast: mockEzspSendBroadcast,
+        ezspSendUnicast: mockEzspSendUnicast,
+        ezspGetNetworkKeyInfo: mockEzspGetNetworkKeyInfo,
+        ezspGetApsKeyInfo: mockEzspGetApsKeyInfo,
+        ezspSetRadioPower: mockEzspSetRadioPower,
+        ezspImportTransientKey: mockEzspImportTransientKey,
+        ezspClearTransientLinkKeys: mockEzspClearTransientLinkKeys,
+        ezspSetLogicalAndRadioChannel: mockEzspSetLogicalAndRadioChannel,
+        ezspSendRawMessage: mockEzspSendRawMessage,
+        ezspSetNWKFrameCounter: mockEzspSetNWKFrameCounter,
+        ezspSetAPSFrameCounter: mockEzspSetAPSFrameCounter,
+    })),
+}));
+
+const ezspMocks = [
+    mockEzspRemoveAllListeners,
+    mockEzspOn,
+    mockEzspOnce,
+    mockEzspStart,
+    mockEzspStop,
+    mockEzspSend,
+    mockEzspSetMulticastTableEntry,
+    mockEzspSetManufacturerCode,
+    mockEzspReadAndClearCounters,
+    mockEzspGetNetworkParameters,
+    mockEzspNetworkState,
+    mockEzspGetEui64,
+    mockEzspSetConcentrator,
+    mockEzspSetSourceRouteDiscoveryMode,
+    mockEzspSetRadioIeee802154CcaMode,
+    mockEzspGetEndpointFlags,
+    mockEzspAddEndpoint,
+    mockEzspNetworkInit,
+    mockEzspExportKey,
+    mockEzspLeaveNetwork,
+    mockEzspSetInitialSecurityState,
+    mockEzspSetExtendedSecurityBitmask,
+    mockEzspClearKeyTable,
+    mockEzspFormNetwork,
+    mockEzspStartWritingStackTokens,
+    mockEzspGetConfigurationValue,
+    mockEzspExportLinkKeyByIndex,
+    mockEzspEraseKeyTableEntry,
+    mockEzspImportLinkKey,
+    mockEzspBroadcastNextNetworkKey,
+    mockEzspBroadcastNetworkKeySwitch,
+    mockEzspStartScan,
+    mockEzspVersion,
+    mockEzspSetProtocolVersion,
+    mockEzspGetVersionStruct,
+    mockEzspSetConfigurationValue,
+    mockEzspSetValue,
+    mockEzspSetPolicy,
+    mockEzspPermitJoining,
+    mockEzspSendBroadcast,
+    mockEzspSendUnicast,
+    mockEzspGetNetworkKeyInfo,
+    mockEzspGetApsKeyInfo,
+    mockEzspSetRadioPower,
+    mockEzspImportTransientKey,
+    mockEzspClearTransientLinkKeys,
+    mockEzspSetLogicalAndRadioChannel,
+    mockEzspSendRawMessage,
+    mockEzspSetNWKFrameCounter,
+    mockEzspSetAPSFrameCounter,
+];
+
+describe("Ember Adapter Layer", () => {
+    let adapter: EmberAdapter;
+    let backupPath: string;
+    const loggerSpies = {
+        debug: vi.spyOn(logger, "debug"),
+        info: vi.spyOn(logger, "info"),
+        warning: vi.spyOn(logger, "warning"),
+        error: vi.spyOn(logger, "error"),
+    };
+
+    const deleteCoordinatorBackup = () => {
+        if (existsSync(backupPath)) {
+            unlinkSync(backupPath);
+        }
+    };
+
+    const deleteStackConfig = () => {
+        if (existsSync(STACK_CONFIG_PATH)) {
+            unlinkSync(STACK_CONFIG_PATH);
+        }
+    };
+
+    const takeResetCodePath = () => {
+        deleteCoordinatorBackup();
+        mockEzspGetNetworkParameters.mockResolvedValueOnce([
+            SLStatus.OK,
+            EmberNodeType.COORDINATOR,
+            {
+                extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+                panId: 1234,
+                radioTxPower: 5,
+                radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                joinMethod: 0,
+                nwkManagerId: 0,
+                nwkUpdateId: 0,
+                channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+            } as EmberNetworkParameters,
+        ]);
+    };
+
+    const takeRestoredCodePath = () => {
+        mockEzspGetNetworkParameters.mockResolvedValueOnce([
+            SLStatus.OK,
+            EmberNodeType.COORDINATOR,
+            {
+                extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+                panId: 1234,
+                radioTxPower: 5,
+                radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                joinMethod: 0,
+                nwkManagerId: 0,
+                nwkUpdateId: 0,
+                channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+            } as EmberNetworkParameters,
+        ]);
+    };
+
+    const clearMocks = () => {
+        for (const mock of ezspMocks) {
+            mock.mockClear();
+        }
+
+        loggerSpies.debug.mockClear();
+        loggerSpies.info.mockClear();
+        loggerSpies.warning.mockClear();
+        loggerSpies.error.mockClear();
+    };
+
+    beforeAll(() => {
+        if (!existsSync(TEMP_PATH)) {
+            mkdirSync(TEMP_PATH);
+        } else {
+            // just in case, remove previous remnants
+            deleteCoordinatorBackup();
+            deleteStackConfig();
+        }
+    });
+
+    afterAll(() => {
+        deleteCoordinatorBackup();
+        deleteStackConfig();
+    });
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+
+        backupPath = path.join(TEMP_PATH, "ember_coordinator_backup.json");
+
+        writeFileSync(backupPath, JSON.stringify(DEFAULT_BACKUP, undefined, 2));
+
+        mockManufCode = Zcl.ManufacturerCode.SILICON_LABORATORIES;
+        mockAPSSequence = -1;
+        mockMessageTag = -1;
+        // make sure emitter is reset too
+        mockEzspEmitter = new EventEmitter();
+
+        clearMocks();
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it("Creates default instance", () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        expect(adapter).toBeInstanceOf(EmberAdapter);
+        expect(adapter.stackConfig).toStrictEqual(DEFAULT_STACK_CONFIG);
+    });
+
+    it("Loads custom stack config", () => {
+        const config = {
+            CONCENTRATOR_RAM_TYPE: "low",
+            CONCENTRATOR_MIN_TIME: 1,
+            CONCENTRATOR_MAX_TIME: 31,
+            CONCENTRATOR_ROUTE_ERROR_THRESHOLD: 5,
+            CONCENTRATOR_DELIVERY_FAILURE_THRESHOLD: 2,
+            CONCENTRATOR_MAX_HOPS: 5,
+            MAX_END_DEVICE_CHILDREN: 16,
+            TRANSIENT_DEVICE_TIMEOUT: 1000,
+            END_DEVICE_POLL_TIMEOUT: 12,
+            TRANSIENT_KEY_TIMEOUT_S: 500,
+            CCA_MODE: "SIGNAL_AND_RSSI",
+        };
+
+        writeFileSync(STACK_CONFIG_PATH, JSON.stringify(config, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        expect(adapter.stackConfig).toStrictEqual(config);
+
+        // cleanup
+        unlinkSync(STACK_CONFIG_PATH);
+    });
+
+    it("Loads only valid custom stack config", () => {
+        const config = {
+            CONCENTRATOR_RAM_TYPE: "bad",
+            CONCENTRATOR_MIN_TIME: -1,
+            CONCENTRATOR_MAX_TIME: 15,
+            CONCENTRATOR_ROUTE_ERROR_THRESHOLD: 500,
+            CONCENTRATOR_DELIVERY_FAILURE_THRESHOLD: 200,
+            CONCENTRATOR_MAX_HOPS: 35,
+            MAX_END_DEVICE_CHILDREN: 65,
+            TRANSIENT_DEVICE_TIMEOUT: 65536,
+            END_DEVICE_POLL_TIMEOUT: 15,
+            TRANSIENT_KEY_TIMEOUT_S: 65536,
+            CCA_MODE: "abcd",
+        };
+
+        writeFileSync(STACK_CONFIG_PATH, JSON.stringify(config, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        expect(adapter.stackConfig).toStrictEqual(DEFAULT_STACK_CONFIG);
+
+        // cleanup
+        unlinkSync(STACK_CONFIG_PATH);
+    });
+
+    it("Loads only valid custom stack config - null CCA_MODE", () => {
+        const config = {
+            CCA_MODE: null,
+        };
+
+        writeFileSync(STACK_CONFIG_PATH, JSON.stringify(config, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        expect(adapter.stackConfig).toStrictEqual(DEFAULT_STACK_CONFIG);
+
+        // cleanup
+        unlinkSync(STACK_CONFIG_PATH);
+    });
+
+    it("Uses default concurrency for queue if not supplied/valid", () => {
+        adapter = new EmberAdapter(
+            DEFAULT_NETWORK_OPTIONS,
+            DEFAULT_SERIAL_PORT_OPTIONS,
+            backupPath,
+            Object.assign({}, DEFAULT_ADAPTER_OPTIONS, {concurrent: undefined}),
+        );
+    });
+
+    it("Starts with resumed when everything matches", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspSetProtocolVersion).toHaveBeenCalledWith(EZSP_PROTOCOL_VERSION);
+        expect(
+            // @ts-expect-error private
+            adapter.networkCache,
+        ).toStrictEqual({
+            eui64: DEFAULT_COORDINATOR_IEEE,
+            parameters: {
+                extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+                panId: DEFAULT_NETWORK_OPTIONS.panID,
+                radioTxPower: 5,
+                radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                joinMethod: 0,
+                nwkManagerId: 0,
+                nwkUpdateId: 0,
+                channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+            } as EmberNetworkParameters,
+        } as NetworkCache);
+    });
+
+    it("Starts with custom stack config", async () => {
+        const config = {
+            CONCENTRATOR_RAM_TYPE: "low",
+            CONCENTRATOR_MIN_TIME: 1,
+            CONCENTRATOR_MAX_TIME: 31,
+            CONCENTRATOR_ROUTE_ERROR_THRESHOLD: 5,
+            CONCENTRATOR_DELIVERY_FAILURE_THRESHOLD: 2,
+            CONCENTRATOR_MAX_HOPS: 5,
+            MAX_END_DEVICE_CHILDREN: 16,
+            TRANSIENT_DEVICE_TIMEOUT: 1000,
+            END_DEVICE_POLL_TIMEOUT: 12,
+            TRANSIENT_KEY_TIMEOUT_S: 500,
+            CCA_MODE: "SIGNAL_AND_RSSI",
+        };
+
+        writeFileSync(STACK_CONFIG_PATH, JSON.stringify(config, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspSetValue).toHaveBeenCalledWith(EzspValueId.TRANSIENT_DEVICE_TIMEOUT, 2, lowHighBytes(config.TRANSIENT_DEVICE_TIMEOUT));
+        expect(mockEzspSetConfigurationValue).toHaveBeenCalledWith(EzspConfigId.MAX_END_DEVICE_CHILDREN, config.MAX_END_DEVICE_CHILDREN);
+        expect(mockEzspSetConfigurationValue).toHaveBeenCalledWith(EzspConfigId.END_DEVICE_POLL_TIMEOUT, config.END_DEVICE_POLL_TIMEOUT);
+        expect(mockEzspSetConfigurationValue).toHaveBeenCalledWith(EzspConfigId.TRANSIENT_KEY_TIMEOUT_S, config.TRANSIENT_KEY_TIMEOUT_S);
+        expect(mockEzspSetConcentrator).toHaveBeenCalledWith(
+            true,
+            EMBER_LOW_RAM_CONCENTRATOR,
+            config.CONCENTRATOR_MIN_TIME,
+            config.CONCENTRATOR_MAX_TIME,
+            config.CONCENTRATOR_ROUTE_ERROR_THRESHOLD,
+            config.CONCENTRATOR_DELIVERY_FAILURE_THRESHOLD,
+            config.CONCENTRATOR_MAX_HOPS,
+        );
+        expect(mockEzspSetRadioIeee802154CcaMode).toHaveBeenCalledWith(IEEE802154CcaMode.SIGNAL_AND_RSSI);
+
+        // cleanup
+        unlinkSync(STACK_CONFIG_PATH);
+    });
+
+    it("Starts with custom stack config invalid CCA_MODE", async () => {
+        const config = {
+            CCA_MODE: "abcd",
+        };
+
+        writeFileSync(STACK_CONFIG_PATH, JSON.stringify(config, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspSetRadioIeee802154CcaMode).toHaveBeenCalledTimes(0);
+
+        // cleanup
+        unlinkSync(STACK_CONFIG_PATH);
+    });
+
+    it("Starts with restored when no network in adapter", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const expectedNetParams: EmberNetworkParameters = {
+            extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+            panId: DEFAULT_NETWORK_OPTIONS.panID,
+            radioTxPower: 5,
+            radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+            joinMethod: 0,
+            nwkManagerId: 0,
+            nwkUpdateId: 0,
+            channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+        };
+
+        mockEzspNetworkInit.mockResolvedValueOnce(SLStatus.NOT_JOINED);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        expect(mockEzspSetNWKFrameCounter).toHaveBeenCalledWith(DEFAULT_BACKUP.network_key.frame_counter);
+        // expect(mockEzspSetAPSFrameCounter).toHaveBeenCalledWith(DEFAULT_BACKUP.???.???);
+        expect(mockEzspFormNetwork).toHaveBeenCalledWith(expectedNetParams);
+        await expect(result).resolves.toStrictEqual("restored");
+    });
+
+    it("Starts with restored when network param mismatch but backup available", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const expectedNetParams: EmberNetworkParameters = {
+            extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+            panId: DEFAULT_NETWORK_OPTIONS.panID,
+            radioTxPower: 5,
+            radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+            joinMethod: 0,
+            nwkManagerId: 0,
+            nwkUpdateId: 0,
+            channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+        };
+
+        mockEzspGetNetworkParameters.mockResolvedValueOnce([
+            SLStatus.OK,
+            EmberNodeType.COORDINATOR,
+            {
+                extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+                panId: 1234,
+                radioTxPower: 5,
+                radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                joinMethod: 0,
+                nwkManagerId: 0,
+                nwkUpdateId: 0,
+                channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+            } as EmberNetworkParameters,
+        ]);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        expect(mockEzspSetNWKFrameCounter).toHaveBeenCalledWith(DEFAULT_BACKUP.network_key.frame_counter);
+        // expect(mockEzspSetAPSFrameCounter).toHaveBeenCalledWith(DEFAULT_BACKUP.???.???);
+        expect(mockEzspFormNetwork).toHaveBeenCalledWith(expectedNetParams);
+        await expect(result).resolves.toStrictEqual("restored");
+    });
+
+    it("Starts with restored when network key mismatch but backup available", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const expectedNetParams: EmberNetworkParameters = {
+            extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+            panId: DEFAULT_NETWORK_OPTIONS.panID,
+            radioTxPower: 5,
+            radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+            joinMethod: 0,
+            nwkManagerId: 0,
+            nwkUpdateId: 0,
+            channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+        };
+
+        mockEzspGetNetworkParameters.mockResolvedValueOnce([SLStatus.OK, EmberNodeType.COORDINATOR, expectedNetParams]);
+
+        const contents = Buffer.from(DEFAULT_BACKUP.network_key.key, "hex").fill(0xff);
+
+        mockEzspExportKey.mockResolvedValueOnce([SLStatus.OK, {contents} as SecManKey]);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("restored");
+        expect(mockEzspSetNWKFrameCounter).toHaveBeenCalledWith(DEFAULT_BACKUP.network_key.frame_counter);
+        // expect(mockEzspSetAPSFrameCounter).toHaveBeenCalledWith(DEFAULT_BACKUP.???.???);
+        expect(mockEzspFormNetwork).toHaveBeenCalledWith(expectedNetParams);
+    });
+
+    it("Starts with reset when networks mismatch but no backup available", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        deleteCoordinatorBackup();
+        mockEzspGetNetworkParameters.mockResolvedValueOnce([
+            SLStatus.OK,
+            EmberNodeType.COORDINATOR,
+            {
+                extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+                panId: 1234,
+                radioTxPower: 5,
+                radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                joinMethod: 0,
+                nwkManagerId: 0,
+                nwkUpdateId: 0,
+                channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+            } as EmberNetworkParameters,
+        ]);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("reset");
+    });
+
+    it("Starts with reset when backup/config mismatch", async () => {
+        adapter = new EmberAdapter(
+            Object.assign({}, DEFAULT_NETWORK_OPTIONS, {panID: 1234}),
+            DEFAULT_SERIAL_PORT_OPTIONS,
+            backupPath,
+            DEFAULT_ADAPTER_OPTIONS,
+        );
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("reset");
+        expect(mockEzspSetNWKFrameCounter).toHaveBeenCalledTimes(0);
+        // expect(mockEzspSetAPSFrameCounter).toHaveBeenCalledTimes(0);
+        expect(mockEzspFormNetwork).toHaveBeenCalledWith({
+            panId: 1234,
+            extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+            radioTxPower: 5, // default when setting `transmitPower` is null/zero
+            radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+            joinMethod: EmberJoinMethod.MAC_ASSOCIATION,
+            nwkManagerId: ZSpec.COORDINATOR_ADDRESS,
+            nwkUpdateId: 0,
+            channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+        } as EmberNetworkParameters);
+    });
+
+    it("Starts with reset and forms with given transmit power", async () => {
+        adapter = new EmberAdapter(
+            Object.assign({}, DEFAULT_NETWORK_OPTIONS, {panID: 1234}),
+            DEFAULT_SERIAL_PORT_OPTIONS,
+            backupPath,
+            Object.assign({}, DEFAULT_ADAPTER_OPTIONS, {transmitPower: 10}),
+        );
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("reset");
+        expect(mockEzspSetNWKFrameCounter).toHaveBeenCalledTimes(0);
+        // expect(mockEzspSetAPSFrameCounter).toHaveBeenCalledTimes(0);
+        expect(mockEzspFormNetwork).toHaveBeenCalledWith({
+            panId: 1234,
+            extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+            radioTxPower: 10,
+            radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+            joinMethod: EmberJoinMethod.MAC_ASSOCIATION,
+            nwkManagerId: ZSpec.COORDINATOR_ADDRESS,
+            nwkUpdateId: 0,
+            channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+        } as EmberNetworkParameters);
+    });
+
+    it("Starts with mismatching transmit power", async () => {
+        adapter = new EmberAdapter(
+            DEFAULT_NETWORK_OPTIONS,
+            DEFAULT_SERIAL_PORT_OPTIONS,
+            backupPath,
+            Object.assign({}, DEFAULT_ADAPTER_OPTIONS, {transmitPower: 10}),
+        );
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspSetRadioPower).toHaveBeenCalledTimes(1);
+        expect(mockEzspSetRadioPower).toHaveBeenCalledWith(10);
+    });
+
+    it("Starts with matching transmit power after form", async () => {
+        adapter = new EmberAdapter(
+            DEFAULT_NETWORK_OPTIONS,
+            DEFAULT_SERIAL_PORT_OPTIONS,
+            backupPath,
+            Object.assign({}, DEFAULT_ADAPTER_OPTIONS, {transmitPower: 10}),
+        );
+        mockEzspNetworkInit.mockResolvedValueOnce(SLStatus.NOT_JOINED);
+        mockEzspGetNetworkParameters.mockResolvedValueOnce([
+            SLStatus.OK,
+            EmberNodeType.COORDINATOR,
+            {
+                extendedPanId: DEFAULT_NETWORK_OPTIONS.extendedPanID!,
+                panId: DEFAULT_NETWORK_OPTIONS.panID,
+                radioTxPower: 10,
+                radioChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                joinMethod: 0,
+                nwkManagerId: 0,
+                nwkUpdateId: 0,
+                channels: ZSpec.ALL_802_15_4_CHANNELS_MASK,
+            } as EmberNetworkParameters,
+        ]);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("restored");
+        expect(mockEzspSetRadioPower).toHaveBeenCalledTimes(0);
+    });
+
+    it("Starts with mismatching transmit power, failure does not present start", async () => {
+        adapter = new EmberAdapter(
+            DEFAULT_NETWORK_OPTIONS,
+            DEFAULT_SERIAL_PORT_OPTIONS,
+            backupPath,
+            Object.assign({}, DEFAULT_ADAPTER_OPTIONS, {transmitPower: 12}),
+        );
+        mockEzspSetRadioPower.mockResolvedValueOnce(SLStatus.FAIL);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspSetRadioPower).toHaveBeenCalledTimes(1);
+        expect(mockEzspSetRadioPower).toHaveBeenCalledWith(12);
+        expect(loggerSpies.error).toHaveBeenCalledWith("Failed to set transmit power to 12 status=FAIL.", "zh:ember");
+    });
+
+    it("Fails to start when EZSP layer fails to start", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        mockEzspStart.mockResolvedValueOnce(EzspStatus.HOST_FATAL_ERROR);
+
+        const result = adapter.start();
+
+        await expect(result).rejects.toThrow(`Failed to start EZSP layer with status=${EzspStatus[EzspStatus.HOST_FATAL_ERROR]}.`);
+    });
+
+    it.each([
+        [
+            "if NCP has improper stack type",
+            () => {
+                mockEzspVersion.mockResolvedValueOnce([14, 1, 123]);
+            },
+            "Stack type 1 is not expected!",
+        ],
+        [
+            "if NCP version unsupported",
+            () => {
+                mockEzspVersion.mockResolvedValueOnce([12, EZSP_STACK_TYPE_MESH, 123]);
+            },
+            `Adapter EZSP protocol version (12) is not supported by Host [${EZSP_MIN_PROTOCOL_VERSION}-${EZSP_PROTOCOL_VERSION}].`,
+        ],
+        [
+            "if NCP has old style version number",
+            () => {
+                mockEzspGetVersionStruct.mockResolvedValueOnce([SLStatus.INVALID_PARAMETER, 0]);
+            },
+            "NCP has old-style version number. Not supported.",
+        ],
+        [
+            "if network is not valid by end of init sequence",
+            () => {
+                mockEzspGetNetworkParameters
+                    .mockResolvedValueOnce([SLStatus.OK, EmberNodeType.COORDINATOR, deepClone(DEFAULT_ADAPTER_NETWORK_PARAMETERS)])
+                    .mockResolvedValueOnce([SLStatus.FAIL, 0, {}]);
+            },
+            "Failed to get network parameters with status=FAIL.",
+        ],
+        [
+            "if could not set concentrator",
+            () => {
+                mockEzspSetConcentrator.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[CONCENTRATOR] Failed to set concentrator with status=FAIL.",
+        ],
+        [
+            "if could not add endpoint",
+            () => {
+                mockEzspAddEndpoint.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            `Failed to register endpoint '1' with status=FAIL.`,
+        ],
+        [
+            "if could not set multicast table entry",
+            () => {
+                mockEzspSetMulticastTableEntry.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            `Failed to register group '0' in multicast table with status=FAIL.`,
+        ],
+        [
+            "if could not set TC key request policy",
+            () => {
+                mockEzspSetPolicy
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.BINDING_MODIFICATION_POLICY
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.MESSAGE_CONTENTS_IN_CALLBACK_POLICY
+                    .mockResolvedValueOnce(SLStatus.FAIL); // EzspPolicyId.TC_KEY_REQUEST_POLICY
+            },
+            "[INIT TC] Failed to set EzspPolicyId TC_KEY_REQUEST_POLICY to ALLOW_TC_KEY_REQUESTS_AND_SEND_CURRENT_KEY with status=FAIL.",
+        ],
+        [
+            "if could not set app key request policy",
+            () => {
+                mockEzspSetPolicy
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.BINDING_MODIFICATION_POLICY
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.MESSAGE_CONTENTS_IN_CALLBACK_POLICY
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.TC_KEY_REQUEST_POLICY
+                    .mockResolvedValueOnce(SLStatus.FAIL); // EzspPolicyId.APP_KEY_REQUEST_POLICY
+            },
+            "[INIT TC] Failed to set EzspPolicyId APP_KEY_REQUEST_POLICY to DENY_APP_KEY_REQUESTS with status=FAIL.",
+        ],
+        [
+            "if could not set app key request policy",
+            () => {
+                mockEzspSetPolicy
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.BINDING_MODIFICATION_POLICY
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.MESSAGE_CONTENTS_IN_CALLBACK_POLICY
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.TC_KEY_REQUEST_POLICY
+                    .mockResolvedValueOnce(SLStatus.OK) // EzspPolicyId.APP_KEY_REQUEST_POLICY
+                    .mockResolvedValueOnce(SLStatus.FAIL); // EzspPolicyId.TRUST_CENTER_POLICY
+            },
+            "[INIT TC] Failed to set join policy to USE_PRECONFIGURED_KEY with status=FAIL.",
+        ],
+        [
+            "if could not init network",
+            () => {
+                mockEzspNetworkInit.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[INIT TC] Failed network init request with status=FAIL.",
+        ],
+        [
+            "if could not export network key",
+            () => {
+                mockEzspExportKey.mockResolvedValueOnce([SLStatus.FAIL, Buffer.alloc(16)]);
+            },
+            "[INIT TC] Failed to export Network Key with status=FAIL.",
+        ],
+        [
+            "if could not leave network",
+            () => {
+                // force leave code path
+                mockEzspGetNetworkParameters.mockResolvedValueOnce([SLStatus.FAIL, 0, {}]);
+                mockEzspLeaveNetwork.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[INIT TC] Failed leave network request with status=FAIL.",
+        ],
+        [
+            "if form could not set NWK frame counter",
+            () => {
+                takeRestoredCodePath();
+                mockEzspSetNWKFrameCounter.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[INIT FORM] Failed to set NWK frame counter with status=FAIL.",
+        ],
+        // [
+        //     'if form could not set TC APS frame counter',
+        //     () => {
+        //         takeRestoredCodePath();
+        //         mockEzspSetAPSFrameCounter.mockResolvedValueOnce(SLStatus.FAIL);
+        //     },
+        //     `[INIT FORM] Failed to set TC APS frame counter with status=FAIL.`,
+        // ],
+        [
+            "if form could not set initial security state",
+            () => {
+                takeResetCodePath();
+                mockEzspSetInitialSecurityState.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[INIT FORM] Failed to set initial security state with status=FAIL.",
+        ],
+        [
+            "if form could not set extended security bitmask",
+            () => {
+                takeResetCodePath();
+                mockEzspSetExtendedSecurityBitmask.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[INIT FORM] Failed to set extended security bitmask to 272 with status=FAIL.",
+        ],
+        [
+            "if could not form network",
+            () => {
+                takeResetCodePath();
+                mockEzspFormNetwork.mockResolvedValueOnce(SLStatus.FAIL);
+            },
+            "[INIT FORM] Failed form network request with status=FAIL.",
+        ],
+        [
+            "if backup corrupted",
+            () => {
+                writeFileSync(backupPath, "abcd");
+            },
+            "[BACKUP] Coordinator backup is corrupted.",
+        ],
+        [
+            "if backup unsupported",
+            () => {
+                const customBackup = deepClone(DEFAULT_BACKUP);
+                // @ts-expect-error mock override
+                customBackup.metadata.version = 2;
+
+                writeFileSync(backupPath, JSON.stringify(customBackup, undefined, 2));
+            },
+            "[BACKUP] Unsupported open coordinator backup version (version=2).",
+        ],
+        [
+            "if backup not EmberZNet stack specific",
+            () => {
+                const customBackup = deepClone(DEFAULT_BACKUP);
+                customBackup.stack_specific!.ezsp = undefined;
+
+                writeFileSync(backupPath, JSON.stringify(customBackup, undefined, 2));
+            },
+            "[BACKUP] Current backup file is not for EmberZNet stack.",
+        ],
+        [
+            "if backup not EmberZNet EZSP version",
+            () => {
+                const customBackup = deepClone(DEFAULT_BACKUP);
+                customBackup.metadata.internal.ezspVersion = undefined;
+
+                writeFileSync(backupPath, JSON.stringify(customBackup, undefined, 2));
+            },
+            "[BACKUP] Current backup file is not for EmberZNet stack.",
+        ],
+        [
+            "if backup unknown format",
+            () => {
+                const customBackup = deepClone(DEFAULT_BACKUP);
+                // @ts-expect-error mock override
+                customBackup.metadata.format = "unknown";
+
+                writeFileSync(backupPath, JSON.stringify(customBackup, undefined, 2));
+            },
+            "[BACKUP] Unknown backup format.",
+        ],
+    ])("Fails to start %s", async (_reason, setup, error) => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        setup();
+
+        const result = defuseRejection(adapter.start());
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).rejects.toThrow(error);
+    });
+
+    it("Warns if NCP has non-GA firmware", async () => {
+        const type: EmberVersionType = EmberVersionType.ALPHA_1;
+
+        mockEzspGetVersionStruct.mockResolvedValueOnce([
+            SLStatus.OK,
+            {
+                build: 135,
+                major: 8,
+                minor: 0,
+                patch: 0,
+                special: 0,
+                type,
+            } as EmberVersion,
+        ]);
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+
+        expect(loggerSpies.warning).toHaveBeenCalledWith(`Adapter is running a non-GA version (${EmberVersionType[type]}).`, "zh:ember");
+    });
+
+    it("Switches EZSP protocol when supported", async () => {
+        mockEzspVersion.mockResolvedValueOnce([EZSP_MIN_PROTOCOL_VERSION, EZSP_STACK_TYPE_MESH, 123]);
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspVersion).toHaveBeenNthCalledWith(1, EZSP_PROTOCOL_VERSION);
+        expect(mockEzspVersion).toHaveBeenNthCalledWith(2, EZSP_MIN_PROTOCOL_VERSION);
+        expect(mockEzspSetProtocolVersion).toHaveBeenCalledWith(EZSP_MIN_PROTOCOL_VERSION);
+    });
+
+    it("Logs failed set config value on start", async () => {
+        mockEzspSetConfigurationValue.mockResolvedValueOnce(SLStatus.ALLOCATION_FAILED);
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+
+        expect(loggerSpies.info).toHaveBeenCalledWith(
+            `[EzspConfigId] Failed to SET '${EzspConfigId[EzspConfigId.TRUST_CENTER_ADDRESS_CACHE_SIZE]}' TO '2' with status=${SLStatus[SLStatus.ALLOCATION_FAILED]}. Firmware value will be used instead.`,
+            "zh:ember",
+        );
+    });
+
+    it("Starts and skips adding endpoint if already present", async () => {
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+        mockEzspGetEndpointFlags
+            .mockResolvedValueOnce([SLStatus.NOT_FOUND, EzspEndpointFlag.DISABLED])
+            .mockResolvedValueOnce([SLStatus.OK, EzspEndpointFlag.ENABLED]); // mock GP already registered
+
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(mockEzspAddEndpoint).toHaveBeenCalledTimes(1);
+        const ep = FIXED_ENDPOINTS[0];
+        expect(mockEzspAddEndpoint).toHaveBeenCalledWith(
+            ep.endpoint,
+            ep.profileId,
+            ep.deviceId,
+            ep.deviceVersion,
+            ep.inClusterList.slice(), // copy
+            ep.outClusterList.slice(), // copy
+        );
+    });
+
+    it("Starts and detects when network key frame counter will soon wrap to 0", async () => {
+        const customBackup = deepClone(DEFAULT_BACKUP);
+        customBackup.network_key.frame_counter = 0xfeeeeeef;
+
+        writeFileSync(backupPath, JSON.stringify(customBackup, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(logger.warning).toHaveBeenCalledWith(
+            "[INIT TC] Network key frame counter is reaching its limit. A new network key will have to be instaured soon.",
+            "zh:ember",
+        );
+    });
+
+    it("Starts and soft-fails if unable to clear key table", async () => {
+        takeResetCodePath();
+        mockEzspClearKeyTable.mockResolvedValueOnce(SLStatus.FAIL);
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const result = adapter.start();
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("reset");
+        expect(loggerSpies.error).toHaveBeenCalledWith("[INIT FORM] Failed to clear key table with status=FAIL.", "zh:ember");
+    });
+
+    it("Starts but ignores backup if unsupported version", async () => {
+        const customBackup = deepClone(DEFAULT_BACKUP);
+        customBackup.metadata.internal.ezspVersion = 11;
+
+        writeFileSync(backupPath, JSON.stringify(customBackup, undefined, 2));
+
+        adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+        const result = adapter.start();
+        const old = `${backupPath}.old`;
+
+        await vi.advanceTimersByTimeAsync(5000);
+        await expect(result).resolves.toStrictEqual("resumed");
+        expect(existsSync(old)).toBeTruthy();
+        expect(loggerSpies.warning).toHaveBeenCalledWith(
+            "[BACKUP] Current backup file is from an unsupported EZSP version. Renaming and ignoring.",
+            "zh:ember",
+        );
+
+        // cleanup
+        unlinkSync(old);
+    });
+
+    describe("When started", () => {
+        beforeEach(async () => {
+            adapter = new EmberAdapter(DEFAULT_NETWORK_OPTIONS, DEFAULT_SERIAL_PORT_OPTIONS, backupPath, DEFAULT_ADAPTER_OPTIONS);
+
+            const result = adapter.start();
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await result;
+
+            // clean slate "post-start"
+            clearMocks();
+        });
+
+        it("Stops Ezsp layer on stop", async () => {
+            // @ts-expect-error private
+            const ezspStopSpy = vi.spyOn(adapter.ezsp, "stop");
+            // @ts-expect-error private
+            const ezspRemoveAllListenersSpy = vi.spyOn(adapter.ezsp, "removeAllListeners");
+
+            await adapter.stop();
+
+            expect(ezspStopSpy).toHaveBeenCalledTimes(1);
+            expect(ezspRemoveAllListenersSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it("Retrieves parameters from cache when cache valid", async () => {
+            await expect(adapter.emberGetEui64()).resolves.toStrictEqual(DEFAULT_COORDINATOR_IEEE);
+            expect(mockEzspGetEui64).toHaveBeenCalledTimes(0);
+
+            await expect(adapter.emberGetPanId()).resolves.toStrictEqual(DEFAULT_NETWORK_OPTIONS.panID);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(0);
+
+            await expect(adapter.emberGetExtendedPanId()).resolves.toStrictEqual(DEFAULT_NETWORK_OPTIONS.extendedPanID!);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(0);
+
+            await expect(adapter.emberGetRadioChannel()).resolves.toStrictEqual(DEFAULT_NETWORK_OPTIONS.channelList[0]);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(0);
+        });
+
+        it("Retrieves parameters from NCP when cache invalid", async () => {
+            adapter.clearNetworkCache();
+            await expect(adapter.emberGetEui64()).resolves.toStrictEqual(DEFAULT_COORDINATOR_IEEE);
+            expect(mockEzspGetEui64).toHaveBeenCalledTimes(1);
+
+            adapter.clearNetworkCache();
+            await expect(adapter.emberGetPanId()).resolves.toStrictEqual(DEFAULT_NETWORK_OPTIONS.panID);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(1);
+
+            adapter.clearNetworkCache();
+            await expect(adapter.emberGetExtendedPanId()).resolves.toStrictEqual(DEFAULT_NETWORK_OPTIONS.extendedPanID!);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(2);
+
+            adapter.clearNetworkCache();
+            await expect(adapter.emberGetRadioChannel()).resolves.toStrictEqual(DEFAULT_NETWORK_OPTIONS.channelList[0]);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(3);
+        });
+
+        it("Throws when failed to retrieve parameter from NCP", async () => {
+            mockEzspGetNetworkParameters
+                .mockResolvedValueOnce([SLStatus.FAIL, 0, {}])
+                .mockResolvedValueOnce([SLStatus.FAIL, 0, {}])
+                .mockResolvedValueOnce([SLStatus.FAIL, 0, {}]);
+
+            adapter.clearNetworkCache();
+
+            const p1 = defuseRejection(adapter.emberGetPanId());
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p1).rejects.toThrow("Failed to get PAN ID (via network parameters) with status=FAIL.");
+
+            adapter.clearNetworkCache();
+
+            const p2 = defuseRejection(adapter.emberGetExtendedPanId());
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p2).rejects.toThrow("Failed to get Extended PAN ID (via network parameters) with status=FAIL.");
+
+            adapter.clearNetworkCache();
+
+            const p3 = defuseRejection(adapter.emberGetRadioChannel());
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p3).rejects.toThrow("Failed to get radio channel (via network parameters) with status=FAIL.");
+        });
+
+        it("Logs stack status change", async () => {
+            mockEzspEmitter.emit("stackStatus", SLStatus.ZIGBEE_TRUST_CENTER_SWAP_EUI_HAS_CHANGED);
+            await flushPromises();
+
+            expect(loggerSpies.debug).toHaveBeenCalledWith(
+                `[STACK STATUS] ${SLStatus[SLStatus.ZIGBEE_TRUST_CENTER_SWAP_EUI_HAS_CHANGED]}.`,
+                "zh:ember",
+            );
+        });
+
+        it("Handles message delivery failure", async () => {
+            let apsFrame: EmberApsFrame = {
+                profileId: ZSpec.HA_PROFILE_ID,
+                clusterId: Zcl.Clusters.genBasic.ID,
+                sourceEndpoint: 1,
+                destinationEndpoint: 1,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit("messageSent", SLStatus.ZIGBEE_DELIVERY_FAILED, EmberOutgoingMessageType.BROADCAST, 1234, apsFrame, 1);
+            await flushPromises();
+
+            expect(loggerSpies.error).toHaveBeenCalledWith(`Delivery of BROADCAST failed for '1234'.`, "zh:ember");
+
+            const spyDeliveryFailedFor = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "deliveryFailedFor",
+            );
+
+            apsFrame = {
+                profileId: ZSpec.HA_PROFILE_ID,
+                clusterId: Zcl.Clusters.genBasic.ID,
+                sourceEndpoint: 1,
+                destinationEndpoint: 1,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit("messageSent", SLStatus.ZIGBEE_DELIVERY_FAILED, EmberOutgoingMessageType.DIRECT, 1234, apsFrame, 1);
+            await flushPromises();
+
+            expect(spyDeliveryFailedFor).toHaveBeenCalledTimes(1);
+            expect(spyDeliveryFailedFor).toHaveBeenCalledWith(1234, apsFrame);
+        });
+
+        it("Registers message unknown group in multicast table", async () => {
+            // @ts-expect-error private
+            const tableIdx = adapter.multicastTable.length;
+            const apsFrame = {
+                profileId: ZSpec.HA_PROFILE_ID,
+                clusterId: Zcl.Clusters.genBasic.ID,
+                sourceEndpoint: 1,
+                destinationEndpoint: 0xff,
+                options: 0,
+                groupId: 123,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit("messageSent", SLStatus.OK, EmberOutgoingMessageType.MULTICAST, 1234, apsFrame, 1);
+            await flushPromises();
+
+            expect(mockEzspSetMulticastTableEntry).toHaveBeenCalledTimes(1);
+            expect(mockEzspSetMulticastTableEntry).toHaveBeenCalledWith(tableIdx, {
+                multicastId: 123,
+                endpoint: FIXED_ENDPOINTS[0].endpoint,
+                networkIndex: FIXED_ENDPOINTS[0].networkIndex,
+            } as EmberMulticastTableEntry);
+            expect(
+                // @ts-expect-error private
+                adapter.multicastTable.length,
+            ).toStrictEqual(tableIdx + 1);
+        });
+
+        it("Fails to register message unknown group in multicast table", async () => {
+            mockEzspSetMulticastTableEntry.mockResolvedValueOnce(SLStatus.FAIL);
+
+            // @ts-expect-error private
+            const tableIdx = adapter.multicastTable.length;
+            const apsFrame = {
+                profileId: ZSpec.HA_PROFILE_ID,
+                clusterId: Zcl.Clusters.genBasic.ID,
+                sourceEndpoint: 1,
+                destinationEndpoint: 0xff,
+                options: 0,
+                groupId: 123,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit("messageSent", SLStatus.OK, EmberOutgoingMessageType.MULTICAST, 1234, apsFrame, 1);
+            await flushPromises();
+
+            expect(mockEzspSetMulticastTableEntry).toHaveBeenCalledTimes(1);
+            expect(mockEzspSetMulticastTableEntry).toHaveBeenCalledWith(tableIdx, {
+                multicastId: 123,
+                endpoint: FIXED_ENDPOINTS[0].endpoint,
+                networkIndex: FIXED_ENDPOINTS[0].networkIndex,
+            } as EmberMulticastTableEntry);
+            expect(
+                // @ts-expect-error private
+                adapter.multicastTable.length,
+            ).toStrictEqual(tableIdx); // not increased, entry was removed
+        });
+
+        it("Emits network address event on ZDO NETWORK_ADDRESS_RESPONSE", async () => {
+            const spyResolveZDO = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZDO",
+            );
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const sender = 1234;
+            const apsFrame: EmberApsFrame = {
+                profileId: Zdo.ZDO_PROFILE_ID,
+                clusterId: Zdo.ClusterId.NETWORK_ADDRESS_RESPONSE,
+                sourceEndpoint: Zdo.ZDO_ENDPOINT,
+                destinationEndpoint: Zdo.ZDO_ENDPOINT,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit(
+                "zdoResponse",
+                apsFrame,
+                sender,
+                Buffer.from([1, Zdo.Status.SUCCESS, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0x11, 0x22, 0x33, 0xd2, 0x04]),
+            );
+            await flushPromises();
+
+            const zdoResponse = [
+                Zdo.Status.SUCCESS,
+                {
+                    eui64: "0x332211eeddccbbaa",
+                    nwkAddress: sender,
+                    startIndex: 0,
+                    assocDevList: [],
+                } as ZdoTypes.NetworkAddressResponse,
+            ];
+
+            expect(spyResolveZDO).toHaveBeenCalledTimes(1);
+            expect(spyResolveZDO).toHaveBeenCalledWith("0x332211eeddccbbaa", apsFrame, zdoResponse);
+            expect(spyEmit).toHaveBeenCalledWith("zdoResponse", Zdo.ClusterId.NETWORK_ADDRESS_RESPONSE, zdoResponse);
+        });
+
+        it("Emits device announce event on ZDO END_DEVICE_ANNOUNCE", async () => {
+            const spyResolveZDO = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZDO",
+            );
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const sender = 1234;
+            const apsFrame: EmberApsFrame = {
+                profileId: Zdo.ZDO_PROFILE_ID,
+                clusterId: Zdo.ClusterId.END_DEVICE_ANNOUNCE,
+                sourceEndpoint: Zdo.ZDO_ENDPOINT,
+                destinationEndpoint: Zdo.ZDO_ENDPOINT,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit("zdoResponse", apsFrame, sender, Buffer.from([1, 0xd2, 0x04, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0x11, 0x22, 0x33, 6]));
+
+            await flushPromises();
+
+            const zdoResponse = [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: sender,
+                    eui64: "0x332211eeddccbbaa",
+                    capabilities: {
+                        alternatePANCoordinator: 0,
+                        deviceType: 1,
+                        powerSource: 1,
+                        rxOnWhenIdle: 0,
+                        reserved1: 0,
+                        reserved2: 0,
+                        securityCapability: 0,
+                        allocateAddress: 0,
+                    },
+                } as ZdoTypes.EndDeviceAnnounce,
+            ];
+            expect(spyResolveZDO).toHaveBeenCalledTimes(1);
+            expect(spyResolveZDO).toHaveBeenCalledWith(sender, apsFrame, zdoResponse);
+            expect(spyEmit).toHaveBeenCalledWith("zdoResponse", Zdo.ClusterId.END_DEVICE_ANNOUNCE, zdoResponse);
+        });
+
+        it("Emits ZCL payload on incoming message", async () => {
+            const spyResolveZCL = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZCL",
+            );
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const sender = 1234;
+            const apsFrame: EmberApsFrame = {
+                profileId: ZSpec.HA_PROFILE_ID,
+                clusterId: Zcl.Clusters.genBasic.ID,
+                sourceEndpoint: 2,
+                destinationEndpoint: 1,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+            const lastHopLqi = 252;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspEmitter.emit("incomingMessage", EmberIncomingMessageType.UNICAST, apsFrame, lastHopLqi, sender, messageContents);
+            await flushPromises();
+
+            const payload: ZclPayload = {
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: sender,
+                data: messageContents,
+                endpoint: apsFrame.sourceEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.destinationEndpoint,
+            };
+
+            expect(spyResolveZCL).toHaveBeenCalledTimes(1);
+            expect(spyResolveZCL).toHaveBeenCalledWith(payload);
+            expect(spyEmit).toHaveBeenCalledWith("zclPayload", payload);
+        });
+
+        it("Emits ZCL payload on touchlink message", async () => {
+            const spyResolveZCL = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZCL",
+            );
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const sourcePanId: PanId = 0x1234;
+            const sourceAddress: Eui64 = "0x1122334455aabbcc";
+            const lastHopLqi = 252;
+            const groupId: number = 0;
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspEmitter.emit("touchlinkMessage", sourcePanId, sourceAddress, groupId, lastHopLqi, messageContents);
+            await flushPromises();
+
+            const payload: ZclPayload = {
+                clusterID: Zcl.Clusters.touchlink.ID,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: sourceAddress,
+                data: messageContents,
+                endpoint: 1,
+                linkquality: lastHopLqi,
+                groupID: groupId,
+                wasBroadcast: true,
+                destinationEndpoint: FIXED_ENDPOINTS[0].endpoint,
+            };
+
+            expect(spyResolveZCL).toHaveBeenCalledTimes(1);
+            expect(spyResolveZCL).toHaveBeenCalledWith(payload);
+            expect(spyEmit).toHaveBeenCalledWith("zclPayload", payload);
+        });
+
+        it("Emits ZCL payload on greenpower message", async () => {
+            const spyResolveZCL = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZCL",
+            );
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const sourceId: number = 1234;
+            const nwkAddress: NodeId = sourceId & 0xffff;
+            const gpdLink: number = 123;
+            const sequenceNumber: number = 1;
+            const commandIdentifier: number = Zcl.Clusters.greenPower.commands.commissioningNotification.ID;
+            const frameCounter: number = 102;
+            const gpdCommandId: number = 0xe0;
+            const gpdCommandPayload = Buffer.from([
+                0x02 /* deviceID */,
+                0x83 /* options */,
+                0xf2 /* extendedOptions */,
+                ...[0xf1, 0xec, 0x92, 0xab, 0xff, 0x8f, 0x13, 0x63, 0xe1, 0x46, 0xbe, 0xb5, 0x18, 0xc9, 0x0c, 0xab] /* securityKey */,
+                0xa4,
+                0x46,
+                0xd4,
+                0xd5 /* keyMic */,
+                0xe4,
+                0x04,
+                0x00,
+                0x00 /* outgoingCounter */,
+            ]);
+            const gpdHeader = Buffer.alloc(15);
+            gpdHeader.writeUInt8(0b00000001, 0);
+            gpdHeader.writeUInt8(sequenceNumber, 1);
+            gpdHeader.writeUInt8(commandIdentifier, 2);
+            gpdHeader.writeUInt16LE(0, 3);
+            gpdHeader.writeUInt32LE(sourceId, 5);
+            gpdHeader.writeUInt32LE(frameCounter, 9);
+            gpdHeader.writeUInt8(gpdCommandId, 13);
+            gpdHeader.writeUInt8(gpdCommandPayload.length, 14);
+            const messageContents = Buffer.concat([gpdHeader, gpdCommandPayload]);
+            const apsFrame: EmberApsFrame = {
+                profileId: ZSpec.GP_PROFILE_ID,
+                clusterId: Zcl.Clusters.greenPower.ID,
+                sourceEndpoint: ZSpec.GP_ENDPOINT,
+                destinationEndpoint: ZSpec.GP_ENDPOINT,
+                options: 0, // not used
+                groupId: ZSpec.GP_GROUP_ID,
+                sequence: 0, // not used
+            };
+
+            mockEzspEmitter.emit("incomingMessage", EmberIncomingMessageType.BROADCAST, apsFrame, gpdLink, nwkAddress, messageContents);
+            await flushPromises();
+
+            const payload: ZclPayload = {
+                header: Zcl.Header.fromBuffer(messageContents),
+                data: messageContents,
+                clusterID: apsFrame.clusterId,
+                address: nwkAddress,
+                endpoint: apsFrame.sourceEndpoint,
+                linkquality: gpdLink,
+                groupID: apsFrame.groupId,
+                wasBroadcast: true,
+                destinationEndpoint: apsFrame.destinationEndpoint,
+            };
+
+            expect(spyResolveZCL).toHaveBeenCalledTimes(1);
+            expect(spyResolveZCL).toHaveBeenCalledWith(payload);
+            expect(spyEmit).toHaveBeenCalledWith("zclPayload", payload);
+        });
+
+        it("Emits device joined on trust center join", async () => {
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const newNodeId: NodeId = 1234;
+            const newNodeEui64: Eui64 = "0x11223344eebbccaa";
+            const status: EmberDeviceUpdate = EmberDeviceUpdate.STANDARD_SECURITY_UNSECURED_JOIN;
+            const policyDecision: EmberJoinDecision = EmberJoinDecision.USE_PRECONFIGURED_KEY;
+            const parentOfNewNodeId: NodeId = 4321;
+
+            mockEzspEmitter.emit("trustCenterJoin", newNodeId, newNodeEui64, status, policyDecision, parentOfNewNodeId);
+            await flushPromises();
+
+            expect(spyEmit).toHaveBeenCalledWith("deviceJoined", {
+                networkAddress: newNodeId,
+                ieeeAddr: newNodeEui64,
+            } as DeviceJoinedPayload);
+        });
+
+        it("Emits device leave on trust center join", async () => {
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const newNodeId: NodeId = 1234;
+            const newNodeEui64: Eui64 = "0x11223344eebbccaa";
+            const status: EmberDeviceUpdate = EmberDeviceUpdate.DEVICE_LEFT;
+            const policyDecision: EmberJoinDecision = EmberJoinDecision.NO_ACTION;
+            const parentOfNewNodeId: NodeId = 0xffff;
+
+            mockEzspEmitter.emit("trustCenterJoin", newNodeId, newNodeEui64, status, policyDecision, parentOfNewNodeId);
+            await flushPromises();
+
+            expect(spyEmit).toHaveBeenCalledWith("deviceLeave", {
+                networkAddress: newNodeId,
+                ieeeAddr: newNodeEui64,
+            } as DeviceLeavePayload);
+        });
+
+        it("Handles DENY_JOIN on trust center join", async () => {
+            const newNodeId: NodeId = 1234;
+            const newNodeEui64: Eui64 = "0x11223344eebbccaa";
+            const status: EmberDeviceUpdate = EmberDeviceUpdate.STANDARD_SECURITY_UNSECURED_JOIN;
+            const policyDecision: EmberJoinDecision = EmberJoinDecision.DENY_JOIN;
+            const parentOfNewNodeId: NodeId = 4321;
+
+            mockEzspEmitter.emit("trustCenterJoin", newNodeId, newNodeEui64, status, policyDecision, parentOfNewNodeId);
+            await flushPromises();
+
+            expect(loggerSpies.warning).toHaveBeenCalledWith(
+                `[TRUST CENTER] Device ${newNodeId}:${newNodeEui64} was denied joining via ${parentOfNewNodeId}.`,
+                "zh:ember",
+            );
+        });
+
+        it("Handles device join workaround requiring specific manufacturer code", async () => {
+            const spyEmit = vi.spyOn(adapter, "emit");
+            const newNodeId: NodeId = 1234;
+            const newNodeEui64: Eui64 = "0x54ef44ffeebbccaa";
+            const status: EmberDeviceUpdate = EmberDeviceUpdate.STANDARD_SECURITY_UNSECURED_JOIN;
+            const policyDecision: EmberJoinDecision = EmberJoinDecision.USE_PRECONFIGURED_KEY;
+            const parentOfNewNodeId: NodeId = 4321;
+
+            mockEzspEmitter.emit("trustCenterJoin", newNodeId, newNodeEui64, status, policyDecision, parentOfNewNodeId);
+            await flushPromises();
+
+            expect(spyEmit).toHaveBeenCalledWith("deviceJoined", {
+                networkAddress: newNodeId,
+                ieeeAddr: newNodeEui64,
+            } as DeviceJoinedPayload);
+            expect(mockEzspSetManufacturerCode).toHaveBeenCalledWith(Zcl.ManufacturerCode.LUMI_UNITED_TECHOLOGY_LTD_SHENZHEN);
+            expect(mockManufCode).toStrictEqual(Zcl.ManufacturerCode.LUMI_UNITED_TECHOLOGY_LTD_SHENZHEN);
+        });
+
+        it("Triggers watchdog counters", async () => {
+            await vi.advanceTimersByTimeAsync(3610000);
+            expect(mockEzspReadAndClearCounters).toHaveBeenCalledTimes(1);
+            expect(loggerSpies.info).toHaveBeenCalledTimes(2);
+            expect(loggerSpies.info.mock.calls[0][0]).toMatch(/[NCP COUNTERS]/);
+            expect(loggerSpies.info.mock.calls[1][0]).toMatch(/[ASH COUNTERS]/);
+        });
+
+        it("Exports link keys", async () => {
+            const k1Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 0,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x1122334455667788",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+            const k1Hashed = ZSpec.Utils.aes128MmoHash(k1);
+            const k1Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 1,
+                incomingFrameCounter: 2,
+                ttlInSeconds: 0,
+            };
+            const k2Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 1,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x2233445566778899",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k2 = Buffer.from([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]);
+            const k2Hashed = ZSpec.Utils.aes128MmoHash(k2);
+            const k2Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 10,
+                incomingFrameCounter: 20,
+                ttlInSeconds: 0,
+            };
+            const k3Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 2,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x3344556677889900",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k3 = Buffer.from([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]);
+            const k3Hashed = ZSpec.Utils.aes128MmoHash(k3);
+            const k3Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 100,
+                incomingFrameCounter: 200,
+                ttlInSeconds: 0,
+            };
+
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 3]);
+            mockEzspExportLinkKeyByIndex
+                .mockResolvedValueOnce([SLStatus.OK, k1Context, {contents: k1} as SecManKey, k1Metadata])
+                .mockResolvedValueOnce([SLStatus.OK, k2Context, {contents: k2} as SecManKey, k2Metadata])
+                .mockResolvedValueOnce([SLStatus.OK, k3Context, {contents: k3} as SecManKey, k3Metadata]);
+
+            const keys = await adapter.exportLinkKeys();
+
+            expect(mockEzspExportLinkKeyByIndex).toHaveBeenCalledTimes(3);
+            expect(keys).toStrictEqual([
+                {
+                    deviceEui64: k1Context.eui64,
+                    key: {contents: k1Hashed},
+                    outgoingFrameCounter: k1Metadata.outgoingFrameCounter,
+                    incomingFrameCounter: k1Metadata.incomingFrameCounter,
+                } as LinkKeyBackupData,
+                {
+                    deviceEui64: k2Context.eui64,
+                    key: {contents: k2Hashed},
+                    outgoingFrameCounter: k2Metadata.outgoingFrameCounter,
+                    incomingFrameCounter: k2Metadata.incomingFrameCounter,
+                } as LinkKeyBackupData,
+                {
+                    deviceEui64: k3Context.eui64,
+                    key: {contents: k3Hashed},
+                    outgoingFrameCounter: k3Metadata.outgoingFrameCounter,
+                    incomingFrameCounter: k3Metadata.incomingFrameCounter,
+                } as LinkKeyBackupData,
+            ]);
+        });
+
+        it("Exports zero link keys", async () => {
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 0]);
+            const keys = await adapter.exportLinkKeys();
+
+            expect(keys).toStrictEqual([]);
+        });
+
+        it("Fails to export link keys due to failed table size retrieval", async () => {
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            await expect(adapter.exportLinkKeys()).rejects.toThrow("[BACKUP] Failed to retrieve key table size from NCP with status=FAIL.");
+        });
+
+        it("Imports link keys", async () => {
+            const k1Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 0,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x1122334455667788",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+            const k1Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 1,
+                incomingFrameCounter: 2,
+                ttlInSeconds: 0,
+            };
+            const k2Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 1,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x2233445566778899",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k2 = Buffer.from([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]);
+            const k2Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 10,
+                incomingFrameCounter: 20,
+                ttlInSeconds: 0,
+            };
+            const k3Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 2,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x3344556677889900",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k3 = Buffer.from([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]);
+            const k3Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 100,
+                incomingFrameCounter: 200,
+                ttlInSeconds: 0,
+            };
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 4]);
+            mockEzspNetworkState.mockResolvedValueOnce(EmberNetworkStatus.NO_NETWORK);
+
+            await adapter.importLinkKeys([
+                {
+                    deviceEui64: k1Context.eui64,
+                    key: {contents: k1},
+                    outgoingFrameCounter: k1Metadata.outgoingFrameCounter,
+                    incomingFrameCounter: k1Metadata.incomingFrameCounter,
+                },
+                {
+                    deviceEui64: k2Context.eui64,
+                    key: {contents: k2},
+                    outgoingFrameCounter: k2Metadata.outgoingFrameCounter,
+                    incomingFrameCounter: k2Metadata.incomingFrameCounter,
+                },
+                {
+                    deviceEui64: k3Context.eui64,
+                    key: {contents: k3},
+                    outgoingFrameCounter: k3Metadata.outgoingFrameCounter,
+                    incomingFrameCounter: k3Metadata.incomingFrameCounter,
+                },
+            ]);
+
+            expect(mockEzspImportLinkKey).toHaveBeenCalledTimes(3);
+            expect(mockEzspEraseKeyTableEntry).toHaveBeenCalledTimes(1);
+        });
+
+        it("Imports zero link keys", async () => {
+            await expect(adapter.importLinkKeys([])).resolves.toStrictEqual(undefined);
+        });
+
+        it("Failed to import link keys due to failed table size retrieval", async () => {
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            await expect(
+                adapter.importLinkKeys([
+                    // @ts-expect-error mock, unnecessary
+                    {},
+                ]),
+            ).rejects.toThrow("[BACKUP] Failed to retrieve key table size from NCP with status=FAIL.");
+        });
+
+        it("Failed to import link keys due to insufficient table size", async () => {
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 0]);
+
+            await expect(
+                adapter.importLinkKeys([
+                    // @ts-expect-error mock, unnecessary
+                    {},
+                ]),
+            ).rejects.toThrow("[BACKUP] Current key table of 0 is too small to import backup of 1!");
+        });
+
+        it("Failed to import link keys due to improper network state", async () => {
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 3]);
+            mockEzspNetworkState.mockResolvedValueOnce(EmberNetworkStatus.JOINED_NETWORK);
+
+            await expect(
+                adapter.importLinkKeys([
+                    // @ts-expect-error mock, unnecessary
+                    {},
+                ]),
+            ).rejects.toThrow(
+                `[BACKUP] Cannot import TC data while network is up, networkStatus=${EmberNetworkStatus[EmberNetworkStatus.JOINED_NETWORK]}.`,
+            );
+        });
+
+        it("Failed to import link keys due to failed key set", async () => {
+            const k1Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 0,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x1122334455667788",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+            const k1Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 1,
+                incomingFrameCounter: 2,
+                ttlInSeconds: 0,
+            };
+
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 3]);
+            mockEzspNetworkState.mockResolvedValueOnce(EmberNetworkStatus.NO_NETWORK);
+            mockEzspImportLinkKey.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(
+                adapter.importLinkKeys([
+                    {
+                        deviceEui64: k1Context.eui64,
+                        key: {contents: k1},
+                        outgoingFrameCounter: k1Metadata.outgoingFrameCounter,
+                        incomingFrameCounter: k1Metadata.incomingFrameCounter,
+                    },
+                ]),
+            ).rejects.toThrow("[BACKUP] Failed to set key table entry at index 0 with status=FAIL.");
+        });
+
+        it("Failed to import link keys due to failed key erase", async () => {
+            const k1Context: SecManContext = {
+                coreKeyType: SecManKeyType.APP_LINK,
+                keyIndex: 0,
+                derivedType: SecManDerivedKeyType.NONE,
+                eui64: "0x1122334455667788",
+                multiNetworkIndex: 0,
+                flags: SecManFlag.EUI_IS_VALID | SecManFlag.KEY_INDEX_IS_VALID,
+                psaKeyAlgPermission: 0,
+            };
+            const k1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+            const k1Metadata: SecManAPSKeyMetadata = {
+                bitmask: EmberKeyStructBitmask.HAS_INCOMING_FRAME_COUNTER | EmberKeyStructBitmask.HAS_OUTGOING_FRAME_COUNTER,
+                outgoingFrameCounter: 1,
+                incomingFrameCounter: 2,
+                ttlInSeconds: 0,
+            };
+
+            mockEzspGetConfigurationValue.mockResolvedValueOnce([SLStatus.OK, 3]);
+            mockEzspNetworkState.mockResolvedValueOnce(EmberNetworkStatus.NO_NETWORK);
+            mockEzspEraseKeyTableEntry.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(
+                adapter.importLinkKeys([
+                    {
+                        deviceEui64: k1Context.eui64,
+                        key: {contents: k1},
+                        outgoingFrameCounter: k1Metadata.outgoingFrameCounter,
+                        incomingFrameCounter: k1Metadata.incomingFrameCounter,
+                    },
+                ]),
+            ).rejects.toThrow("[BACKUP] Failed to erase key table entry at index 1 with status=FAIL.");
+        });
+
+        it("Broadcasts network key update", async () => {
+            const p = adapter.broadcastNetworkKeyUpdate();
+
+            await vi.advanceTimersByTimeAsync(100000);
+            await expect(p).resolves.toStrictEqual(undefined);
+            expect(mockEzspBroadcastNextNetworkKey).toHaveBeenCalledTimes(1);
+            expect(mockEzspBroadcastNetworkKeySwitch).toHaveBeenCalledTimes(1);
+        });
+
+        it("Fails to broadcast network key update due to failed next key broadcast", async () => {
+            mockEzspBroadcastNextNetworkKey.mockResolvedValueOnce(SLStatus.FAIL);
+
+            const p = defuseRejection(adapter.broadcastNetworkKeyUpdate());
+
+            await vi.advanceTimersByTimeAsync(100000);
+            await expect(p).rejects.toThrow("[TRUST CENTER] Failed to broadcast next network key with status=FAIL.");
+            expect(mockEzspBroadcastNextNetworkKey).toHaveBeenCalledTimes(1);
+            expect(mockEzspBroadcastNetworkKeySwitch).toHaveBeenCalledTimes(0);
+        });
+
+        it("Fails to broadcast network key update due to failed switch broadcast", async () => {
+            mockEzspBroadcastNetworkKeySwitch.mockResolvedValueOnce(SLStatus.FAIL);
+
+            const p = defuseRejection(adapter.broadcastNetworkKeyUpdate());
+
+            await vi.advanceTimersByTimeAsync(100000);
+            await expect(p).rejects.toThrow("[TRUST CENTER] Failed to broadcast network key switch with status=FAIL.");
+            expect(mockEzspBroadcastNextNetworkKey).toHaveBeenCalledTimes(1);
+            expect(mockEzspBroadcastNetworkKeySwitch).toHaveBeenCalledTimes(1);
+        });
+
+        it("Handles NCP needing reset & init", async () => {
+            const spyEmit = vi.spyOn(adapter, "emit");
+
+            mockEzspEmitter.emit("ncpNeedsResetAndInit", EzspStatus.ERROR_SERIAL_INIT);
+            await vi.advanceTimersByTimeAsync(5000);
+
+            expect(spyEmit).toHaveBeenCalledTimes(1);
+            expect(spyEmit).toHaveBeenCalledWith("disconnected");
+        });
+
+        it("Emits adapter disconnected when NCP needs reset & init but queue is too high", async () => {
+            vi.spyOn(
+                // @ts-expect-error private
+                adapter.queue,
+                "count",
+            ).mockReturnValueOnce(999);
+            const spyEmit = vi.spyOn(adapter, "emit");
+
+            mockEzspEmitter.emit("ncpNeedsResetAndInit", EzspStatus.ERROR_SERIAL_INIT);
+            await flushPromises();
+
+            expect(spyEmit).toHaveBeenCalledWith("disconnected");
+        });
+
+        it("Emits adapter disconnected when failed to reset & init NCP", async () => {
+            vi.spyOn(adapter, "stop").mockRejectedValueOnce(new Error("mock error"));
+            const spyEmit = vi.spyOn(adapter, "emit");
+
+            mockEzspEmitter.emit("ncpNeedsResetAndInit", EzspStatus.ERROR_SERIAL_INIT);
+            await flushPromises();
+
+            expect(spyEmit).toHaveBeenCalledWith("disconnected");
+        });
+
+        it("Handles channel changed stack status", async () => {
+            mockEzspEmitter.emit("stackStatus", SLStatus.ZIGBEE_CHANNEL_CHANGED);
+            await flushPromises();
+            expect(loggerSpies.info).toHaveBeenCalledWith("[STACK STATUS] Channel changed.", "zh:ember");
+        });
+
+        it.each([
+            ["getCoordinatorIEEE", []],
+            ["getNetworkParameters", []],
+            ["permitJoin", [250, 1234]],
+            ["permitJoin", [250]],
+            [
+                "sendZclFrameToEndpoint",
+                [
+                    "0x1122334455667788",
+                    1234,
+                    1,
+                    Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {}),
+                    10000,
+                    true,
+                    false,
+                    1,
+                ],
+            ],
+            [
+                "sendZclFrameToGroup",
+                [32, Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {}), 1],
+            ],
+            [
+                "sendZclFrameToAll",
+                [
+                    1,
+                    Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {}),
+                    1,
+                    ZSpec.BroadcastAddress.DEFAULT,
+                ],
+            ],
+        ])("Adapter impl: throws when using non-InterPAN function %s while in InterPAN mode", async (funcName, args) => {
+            await adapter.setChannelInterPAN(15);
+
+            await expect(
+                // @ts-expect-error mock
+                adapter[funcName](...args),
+            ).rejects.toThrow("[INTERPAN MODE] Cannot execute non-InterPAN commands.");
+        });
+
+        it("Adapter impl: getCoordinatorIEEE", async () => {
+            await expect(adapter.getCoordinatorIEEE()).resolves.toStrictEqual(DEFAULT_COORDINATOR_IEEE);
+        });
+
+        it("Adapter impl: getCoordinatorVersion", async () => {
+            await expect(adapter.getCoordinatorVersion()).resolves.toStrictEqual({
+                type: "EmberZNet",
+                meta: {
+                    ezsp: EZSP_PROTOCOL_VERSION,
+                    revision: `8.0.0 [${EmberVersionType[EmberVersionType.GA]}]`,
+                    build: 135,
+                    major: 8,
+                    minor: 0,
+                    patch: 0,
+                    special: 0,
+                    type: EmberVersionType.GA,
+                },
+            } as TsType.CoordinatorVersion);
+        });
+
+        it("Adapter impl: reset soft", async () => {
+            await expect(adapter.reset("soft")).rejects.toThrow(`Not supported 'soft'.`);
+        });
+
+        it("Adapter impl: reset hard", async () => {
+            await expect(adapter.reset("hard")).rejects.toThrow(`Not supported 'hard'.`);
+        });
+
+        it("Adapter impl: supportsBackup", async () => {
+            await expect(adapter.supportsBackup()).resolves.toStrictEqual(true);
+        });
+
+        it("Adapter impl: backup", async () => {
+            await expect(adapter.backup([])).resolves.toStrictEqual({
+                networkOptions: {
+                    panId: DEFAULT_NETWORK_OPTIONS.panID, // uint16_t
+                    extendedPanId: Buffer.from(DEFAULT_NETWORK_OPTIONS.extendedPanID!),
+                    channelList: ZSpec.ALL_802_15_4_CHANNELS.slice(),
+                    networkKey: Buffer.from(DEFAULT_BACKUP.network_key.key, "hex"),
+                    networkKeyDistribute: false,
+                },
+                logicalChannel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                networkKeyInfo: {
+                    sequenceNumber: DEFAULT_BACKUP.network_key.sequence_number,
+                    frameCounter: DEFAULT_BACKUP.network_key.frame_counter,
+                },
+                securityLevel: SECURITY_LEVEL_Z3,
+                networkUpdateId: 0,
+                coordinatorIeeeAddress: Buffer.from(DEFAULT_BACKUP.coordinator_ieee, "hex"),
+                devices: [],
+                ezsp: {
+                    version: EZSP_PROTOCOL_VERSION,
+                    hashed_tclk: Buffer.from(DEFAULT_BACKUP.stack_specific!.ezsp!.hashed_tclk!, "hex"),
+                },
+            } as Backup);
+        });
+
+        it.each([
+            [
+                "failed get network parameters",
+                () => {
+                    mockEzspGetNetworkParameters.mockResolvedValueOnce([SLStatus.FAIL, 0, {}]);
+                },
+                "[BACKUP] Failed to get network parameters with status=FAIL.",
+            ],
+            [
+                "failed get network key info",
+                () => {
+                    mockEzspGetNetworkKeyInfo.mockResolvedValueOnce([SLStatus.FAIL, {}]);
+                },
+                "[BACKUP] Failed to get network keys info with status=FAIL.",
+            ],
+            // [
+            //     'failed get TC APS key info',
+            //     () => {
+            //         mockEzspGetNetworkKeyInfo.mockResolvedValueOnce([SLStatus.FAIL, {}]);
+            //     },
+            //     `[BACKUP] Failed to get TC APS key info with status=FAIL.`,
+            // ],
+            [
+                "no network key set",
+                () => {
+                    mockEzspGetNetworkKeyInfo.mockResolvedValueOnce([
+                        SLStatus.OK,
+                        {
+                            networkKeySet: false,
+                            alternateNetworkKeySet: false,
+                            networkKeySequenceNumber: 123,
+                            altNetworkKeySequenceNumber: 0,
+                            networkKeyFrameCounter: 456,
+                        } as SecManNetworkKeyInfo,
+                    ]);
+                },
+                "[BACKUP] No network key set.",
+            ],
+            [
+                "failed export TC link key",
+                () => {
+                    mockEzspExportKey.mockResolvedValueOnce([SLStatus.FAIL, {}]);
+                },
+                "[BACKUP] Failed to export TC Link Key with status=FAIL.",
+            ],
+            [
+                "failed export network key",
+                () => {
+                    mockEzspExportKey
+                        .mockResolvedValueOnce([
+                            SLStatus.OK,
+                            {contents: Buffer.from(DEFAULT_BACKUP.stack_specific!.ezsp!.hashed_tclk!, "hex")} as SecManKey,
+                        ])
+                        .mockResolvedValueOnce([SLStatus.FAIL, {}]);
+                },
+                "[BACKUP] Failed to export Network Key with status=FAIL.",
+            ],
+        ])("Adapter impl: throws when backup fails due to %s", async (_command, setup, error) => {
+            setup();
+
+            await expect(adapter.backup([])).rejects.toThrow(error);
+        });
+
+        it("Adapter impl: getNetworkParameters from cache", async () => {
+            await expect(adapter.getNetworkParameters()).resolves.toStrictEqual({
+                panID: DEFAULT_NETWORK_OPTIONS.panID,
+                extendedPanID: ZSpec.Utils.eui64LEBufferToHex(Buffer.from(DEFAULT_NETWORK_OPTIONS.extendedPanID!)),
+                channel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                nwkUpdateID: 0,
+            } as TsType.NetworkParameters);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(0);
+        });
+
+        it("Adapter impl: getNetworkParameters from NCP", async () => {
+            adapter.clearNetworkCache();
+
+            await expect(adapter.getNetworkParameters()).resolves.toStrictEqual({
+                panID: DEFAULT_NETWORK_OPTIONS.panID,
+                extendedPanID: ZSpec.Utils.eui64LEBufferToHex(Buffer.from(DEFAULT_NETWORK_OPTIONS.extendedPanID!)),
+                channel: DEFAULT_NETWORK_OPTIONS.channelList[0],
+                nwkUpdateID: 0,
+            } as TsType.NetworkParameters);
+            expect(mockEzspGetNetworkParameters).toHaveBeenCalledTimes(1);
+        });
+
+        it("Adapter impl: addInstallCode", async () => {
+            await expect(
+                adapter.addInstallCode("0x1122334455667788", Buffer.from("DD7ED5CDAA8E2C708B67D2B1573DB6843A5F", "hex"), false),
+            ).resolves.toStrictEqual(undefined);
+            expect(mockEzspImportTransientKey).toHaveBeenCalledTimes(1);
+            expect(loggerSpies.debug).toHaveBeenCalledWith(`[ADD INSTALL CODE] Success for '0x1122334455667788'.`, "zh:ember");
+        });
+
+        it("Adapter impl: throw when addInstallCode fails import transient key", async () => {
+            mockEzspImportTransientKey.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(adapter.addInstallCode("0x1122334455667788", Buffer.alloc(16), true)).rejects.toThrow(
+                `[ADD INSTALL CODE] Failed for '0x1122334455667788' with status=FAIL.`,
+            );
+            expect(mockEzspImportTransientKey).toHaveBeenCalledTimes(1);
+        });
+
+        it("Adapter impl: waitFor", () => {
+            const waiter = adapter.waitFor(1234, 1, Zcl.FrameType.GLOBAL, Zcl.Direction.CLIENT_TO_SERVER, 10, 0, 1, 15000);
+            const spyCancel = vi.spyOn(waiter, "cancel");
+
+            expect(typeof waiter.cancel).toStrictEqual("function");
+            expect(waiter.promise).toBeDefined();
+
+            waiter.cancel();
+
+            expect(spyCancel).toHaveReturned();
+        });
+
+        it("Adapter impl: permitJoin on all", async () => {
+            const spyResolveEvent = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveEvent",
+            );
+
+            await adapter.permitJoin(250);
+            await vi.advanceTimersByTimeAsync(1000);
+            expect(mockEzspPermitJoining).toHaveBeenCalledWith(250);
+            expect(mockEzspSendBroadcast).toHaveBeenCalledTimes(1);
+            expect(spyResolveEvent).toHaveBeenCalledWith(OneWaitressEvents.STACK_STATUS_NETWORK_OPENED);
+
+            await adapter.permitJoin(0);
+            await vi.advanceTimersByTimeAsync(1000);
+            expect(mockEzspPermitJoining).toHaveBeenCalledWith(0);
+            expect(mockEzspSendBroadcast).toHaveBeenCalledTimes(2);
+            expect(spyResolveEvent).toHaveBeenCalledWith(OneWaitressEvents.STACK_STATUS_NETWORK_CLOSED);
+
+            expect(mockEzspSetPolicy).toHaveBeenNthCalledWith(
+                1,
+                EzspPolicyId.TRUST_CENTER_POLICY,
+                EzspDecisionBitmask.ALLOW_JOINS | EzspDecisionBitmask.ALLOW_UNSECURED_REJOINS,
+            );
+            expect(mockEzspSetPolicy).toHaveBeenNthCalledWith(2, EzspPolicyId.TRUST_CENTER_POLICY, EzspDecisionBitmask.ALLOW_UNSECURED_REJOINS);
+        });
+
+        it("Adapter impl: permitJoin on coordinator", async () => {
+            const spyResolveEvent = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveEvent",
+            );
+
+            await adapter.permitJoin(250, ZSpec.COORDINATOR_ADDRESS);
+            await vi.advanceTimersByTimeAsync(1000);
+            expect(mockEzspPermitJoining).toHaveBeenCalledWith(250);
+            expect(mockEzspSendBroadcast).toHaveBeenCalledTimes(0);
+            expect(spyResolveEvent).toHaveBeenCalledWith(OneWaitressEvents.STACK_STATUS_NETWORK_OPENED);
+
+            await adapter.permitJoin(0, ZSpec.COORDINATOR_ADDRESS);
+            await vi.advanceTimersByTimeAsync(1000);
+            expect(mockEzspPermitJoining).toHaveBeenCalledWith(0);
+            expect(mockEzspSendBroadcast).toHaveBeenCalledTimes(0);
+            expect(spyResolveEvent).toHaveBeenCalledWith(OneWaitressEvents.STACK_STATUS_NETWORK_CLOSED);
+
+            expect(mockEzspSetPolicy).toHaveBeenNthCalledWith(
+                1,
+                EzspPolicyId.TRUST_CENTER_POLICY,
+                EzspDecisionBitmask.ALLOW_JOINS | EzspDecisionBitmask.ALLOW_UNSECURED_REJOINS,
+            );
+            expect(mockEzspSetPolicy).toHaveBeenNthCalledWith(2, EzspPolicyId.TRUST_CENTER_POLICY, EzspDecisionBitmask.ALLOW_UNSECURED_REJOINS);
+        });
+
+        it("Adapter impl: permitJoin on router", async () => {
+            const spyResolveZDO = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZDO",
+            );
+            const sender = 1234;
+            const apsFrame: EmberApsFrame = {
+                profileId: Zdo.ZDO_PROFILE_ID,
+                clusterId: Zdo.ClusterId.PERMIT_JOINING_RESPONSE,
+                sourceEndpoint: Zdo.ZDO_ENDPOINT,
+                destinationEndpoint: Zdo.ZDO_ENDPOINT,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+            const emitResponse = () => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit("zdoResponse", apsFrame, sender, Buffer.from([1, Zdo.Status.SUCCESS]));
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            };
+
+            mockEzspSendUnicast.mockImplementationOnce(emitResponse).mockImplementationOnce(emitResponse);
+
+            const zdoResponse = [Zdo.Status.SUCCESS, undefined];
+            let p = adapter.permitJoin(250, sender);
+            await vi.advanceTimersByTimeAsync(1000);
+            await p;
+            expect(mockEzspSendUnicast).toHaveBeenCalledTimes(1);
+            expect(spyResolveZDO).toHaveBeenCalledTimes(1);
+            expect(spyResolveZDO).toHaveBeenCalledWith(sender, apsFrame, zdoResponse);
+
+            p = adapter.permitJoin(0, sender);
+            await vi.advanceTimersByTimeAsync(1000);
+            await p;
+            expect(mockEzspSendUnicast).toHaveBeenCalledTimes(2);
+            expect(spyResolveZDO).toHaveBeenCalledTimes(2);
+            expect(spyResolveZDO).toHaveBeenCalledWith(sender, apsFrame, zdoResponse);
+
+            expect(mockEzspSetPolicy).toHaveBeenNthCalledWith(
+                1,
+                EzspPolicyId.TRUST_CENTER_POLICY,
+                EzspDecisionBitmask.ALLOW_JOINS | EzspDecisionBitmask.ALLOW_UNSECURED_REJOINS,
+            );
+            expect(mockEzspSetPolicy).toHaveBeenNthCalledWith(2, EzspPolicyId.TRUST_CENTER_POLICY, EzspDecisionBitmask.ALLOW_UNSECURED_REJOINS);
+        });
+
+        it("Adapter impl: permitJoin restores temp manufacturer code", async () => {
+            const spyResolveEvent = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveEvent",
+            );
+
+            const newNodeId: NodeId = 1234;
+            const newNodeEui64: Eui64 = "0x54ef44ffeebbccaa";
+            const status: EmberDeviceUpdate = EmberDeviceUpdate.STANDARD_SECURITY_UNSECURED_JOIN;
+            const policyDecision: EmberJoinDecision = EmberJoinDecision.USE_PRECONFIGURED_KEY;
+            const parentOfNewNodeId: NodeId = 4321;
+
+            mockEzspEmitter.emit("trustCenterJoin", newNodeId, newNodeEui64, status, policyDecision, parentOfNewNodeId);
+            await flushPromises();
+
+            expect(mockEzspSetManufacturerCode).toHaveBeenCalledWith(Zcl.ManufacturerCode.LUMI_UNITED_TECHOLOGY_LTD_SHENZHEN);
+            expect(mockManufCode).toStrictEqual(Zcl.ManufacturerCode.LUMI_UNITED_TECHOLOGY_LTD_SHENZHEN);
+
+            await adapter.permitJoin(0, ZSpec.COORDINATOR_ADDRESS);
+            await vi.advanceTimersByTimeAsync(1000);
+            expect(mockEzspPermitJoining).toHaveBeenCalledWith(0);
+            expect(mockEzspSendBroadcast).toHaveBeenCalledTimes(0);
+            expect(spyResolveEvent).toHaveBeenCalledWith(OneWaitressEvents.STACK_STATUS_NETWORK_CLOSED);
+            expect(mockEzspSetManufacturerCode).toHaveBeenCalledWith(Zcl.ManufacturerCode.SILICON_LABORATORIES);
+            expect(mockManufCode).toStrictEqual(Zcl.ManufacturerCode.SILICON_LABORATORIES);
+        });
+
+        it("Adapter impl: throws when permitJoin request on coordinator fails", async () => {
+            mockEzspPermitJoining.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(adapter.permitJoin(250, 0)).rejects.toThrow("[ZDO] Failed coordinator permit joining request with status=FAIL.");
+        });
+
+        it("Adapter impl: throws when permitJoin broadcast request fails", async () => {
+            mockEzspSendBroadcast.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            await expect(defuseRejection(adapter.permitJoin(250, undefined))).rejects.toThrow(
+                "~x~> [ZDO PERMIT_JOINING_REQUEST BROADCAST to=65532 messageTag=1] Failed to send request with status=FAIL.",
+            );
+        });
+
+        it("Adapter impl: resolves undefined when permitJoin on router fails due to failed ZDO status", async () => {
+            const spyResolveZDO = vi.spyOn(
+                // @ts-expect-error private
+                adapter.oneWaitress,
+                "resolveZDO",
+            );
+            const sender = 1234;
+            const apsFrame: EmberApsFrame = {
+                profileId: Zdo.ZDO_PROFILE_ID,
+                clusterId: Zdo.ClusterId.PERMIT_JOINING_RESPONSE,
+                sourceEndpoint: Zdo.ZDO_ENDPOINT,
+                destinationEndpoint: Zdo.ZDO_ENDPOINT,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+
+            mockEzspEmitter.emit("zdoResponse", apsFrame, sender, Buffer.from([1, Zdo.Status.NOT_AUTHORIZED]));
+            await flushPromises();
+
+            const zdoResponse = [Zdo.Status.NOT_AUTHORIZED, undefined];
+            expect(spyResolveZDO).toHaveBeenCalledTimes(1);
+            expect(spyResolveZDO).toHaveBeenCalledWith(sender, apsFrame, zdoResponse);
+        });
+
+        it("Adapter impl: throws when permitJoin request on router fails", async () => {
+            mockEzspSendUnicast.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            await expect(adapter.permitJoin(250, 1234)).rejects.toThrow(
+                "~x~> [ZDO PERMIT_JOINING_REQUEST UNICAST to=0xffffffffffffffff:1234 messageTag=1] Failed to send request with status=FAIL.",
+            );
+        });
+
+        it("Adapter impl: throws when permitJoin fails to import ZIGBEE_PROFILE_INTEROPERABILITY_LINK_KEY", async () => {
+            mockEzspImportTransientKey.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(adapter.permitJoin(250)).rejects.toThrow("[ZDO] Failed import transient key with status=FAIL.");
+        });
+
+        it("Adapter impl: throws when permitJoin fails to set TC policy", async () => {
+            mockEzspSetPolicy.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(adapter.permitJoin(250)).rejects.toThrow("[ZDO] Failed set join policy with status=FAIL.");
+        });
+
+        it("Adapter impl: throws when stop permitJoin fails to restore TC policy", async () => {
+            mockEzspSetPolicy.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(adapter.permitJoin(0)).rejects.toThrow("[ZDO] Failed set join policy with status=FAIL.");
+        });
+
+        it("Adapter impl: sendZclFrameToEndpoint with command response with fixed source endpoint", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspSend.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, false, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: sendZclFrameToEndpoint with command response with other source endpoint", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = 3;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspSend.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, false, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: sendZclFrameToEndpoint with command response with no source endpoint", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspSend.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, false, false);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it.each([
+            ["NO_TX_SPACE", EzspStatus.NO_TX_SPACE],
+            ["NOT_CONNECTED", EzspStatus.NOT_CONNECTED],
+        ])("Adapter impl: recovers when sendZclFrameToEndpoint throws %s status", async (_statusName, status) => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspSend.mockRejectedValueOnce(new EzspError(status)).mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, false, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledTimes(2);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it.each([
+            ["ZIGBEE_MAX_MESSAGE_LIMIT_REACHED", SLStatus.ZIGBEE_MAX_MESSAGE_LIMIT_REACHED],
+            ["BUSY", SLStatus.BUSY],
+            ["NETWORK_DOWN", SLStatus.NETWORK_DOWN],
+        ])("Adapter impl: recovers when sendZclFrameToEndpoint get %s status from NCP", async (_statusName, status) => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1803010000002003", "hex");
+
+            mockEzspSend.mockResolvedValueOnce([status, 0]).mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, false, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledTimes(2);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: throws when sendZclFrameToEndpoint throws NO_TX_SPACE status and recovery disabled", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+
+            mockEzspSend.mockRejectedValueOnce(new EzspError(EzspStatus.NO_TX_SPACE));
+
+            const p = defuseRejection(
+                adapter.sendZclFrameToEndpoint(
+                    "0x1122334455667788",
+                    networkAddress,
+                    endpoint,
+                    zclFrame,
+                    10000,
+                    false,
+                    true, // disable recovery
+                    sourceEndpoint,
+                ),
+            );
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).rejects.toThrow(
+                `~x~> [ZCL to=0x1122334455667788:1234 apsFrame={"profileId":260,"clusterId":0,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":0}] Failed to send request with status=${SLStatus[SLStatus.BUSY]}.`,
+            );
+            expect(mockEzspSend).toHaveBeenCalledTimes(1);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: throws when sendZclFrameToEndpoint get BUSY status from NCP and recovery disabled", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+
+            mockEzspSend.mockResolvedValueOnce([SLStatus.BUSY, 0]);
+
+            const p = defuseRejection(
+                adapter.sendZclFrameToEndpoint(
+                    "0x1122334455667788",
+                    networkAddress,
+                    endpoint,
+                    zclFrame,
+                    10000,
+                    false,
+                    true, // disable recovery
+                    sourceEndpoint,
+                ),
+            );
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).rejects.toThrow(
+                `~x~> [ZCL to=0x1122334455667788:1234 apsFrame={"profileId":260,"clusterId":0,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":0}] Failed to send request with status=${SLStatus[SLStatus.BUSY]}.`,
+            );
+            expect(mockEzspSend).toHaveBeenCalledTimes(1);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: throws when sendZclFrameToEndpoint get BUSY status from NCP and exceeded max attempts", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+
+            mockEzspSend
+                .mockResolvedValueOnce([SLStatus.BUSY, 0])
+                .mockResolvedValueOnce([SLStatus.BUSY, 0])
+                .mockResolvedValueOnce([SLStatus.BUSY, 0]);
+
+            const p = defuseRejection(
+                adapter.sendZclFrameToEndpoint(
+                    "0x1122334455667788",
+                    networkAddress,
+                    endpoint,
+                    zclFrame,
+                    10000,
+                    false,
+                    false, // disable recovery
+                    sourceEndpoint,
+                ),
+            );
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).rejects.toThrow(
+                `~x~> [ZCL to=0x1122334455667788:1234 apsFrame={"profileId":260,"clusterId":0,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":0}] Failed to send request with status=${SLStatus[SLStatus.BUSY]}.`,
+            );
+            expect(mockEzspSend).toHaveBeenCalledTimes(3);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: throws when sendZclFrameToEndpoint request fails", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 1;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+
+            mockEzspSend.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            const p = defuseRejection(
+                adapter.sendZclFrameToEndpoint(
+                    "0x1122334455667788",
+                    networkAddress,
+                    endpoint,
+                    zclFrame,
+                    10000,
+                    false,
+                    false, // disable recovery
+                    sourceEndpoint,
+                ),
+            );
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).rejects.toThrow(
+                `~x~> [ZCL to=0x1122334455667788:1234 apsFrame={"profileId":260,"clusterId":0,"sourceEndpoint":1,"destinationEndpoint":1,"options":4416,"groupId":0,"sequence":0}] Failed to send request with status=FAIL.`,
+            );
+            expect(mockEzspSend).toHaveBeenCalledTimes(1);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: sendZdo with EUI64", async () => {
+            const sender: NodeId = 0x6789;
+            const senderEUI64: Eui64 = "0x1122334455667788";
+            const apsFrame: EmberApsFrame = {
+                profileId: Zdo.ZDO_PROFILE_ID,
+                clusterId: Zdo.ClusterId.NETWORK_ADDRESS_RESPONSE,
+                sourceEndpoint: Zdo.ZDO_ENDPOINT,
+                destinationEndpoint: Zdo.ZDO_ENDPOINT,
+                options: 0,
+                groupId: 0,
+                sequence: 0,
+            };
+
+            mockEzspSendBroadcast.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "zdoResponse",
+                        apsFrame,
+                        sender,
+                        Buffer.from([
+                            1,
+                            Zdo.Status.SUCCESS,
+                            0x88,
+                            0x77,
+                            0x66,
+                            0x55,
+                            0x44,
+                            0x33,
+                            0x22,
+                            0x11,
+                            0x89, // nwkAddress
+                            0x67, // nwkAddress
+                        ]),
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const zdoPayload = Zdo.Buffalo.buildRequest(false, Zdo.ClusterId.NETWORK_ADDRESS_REQUEST, senderEUI64, false, 0);
+            const p = adapter.sendZdo(
+                senderEUI64,
+                ZSpec.NULL_NODE_ID /* same as broadcast SLEEPY */,
+                Zdo.ClusterId.NETWORK_ADDRESS_REQUEST,
+                zdoPayload,
+                false,
+            );
+
+            await vi.advanceTimersByTimeAsync(1000);
+            await expect(p).resolves.toStrictEqual([
+                Zdo.Status.SUCCESS,
+                {
+                    eui64: senderEUI64,
+                    nwkAddress: sender,
+                    startIndex: 0,
+                    assocDevList: [],
+                } as ZdoTypes.NetworkAddressResponse,
+            ]);
+        });
+
+        it("Adapter impl: sendZclFrameToEndpoint with default response", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 3;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                false,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+            const lastHopLqi: number = 234;
+            // defaultRsp with cmdId=0, status=0
+            const messageContents = Buffer.from("18030b0000", "hex");
+
+            mockEzspSend.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit(
+                        "incomingMessage",
+                        EmberIncomingMessageType.UNICAST,
+                        reverseApsFrame(apsFrame),
+                        lastHopLqi,
+                        networkAddress,
+                        messageContents,
+                    );
+                    await flushPromises();
+                }, 300);
+
+                return [SLStatus.OK, ++mockAPSSequence];
+            });
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, true, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual({
+                clusterID: apsFrame.clusterId,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: networkAddress,
+                data: messageContents,
+                endpoint: apsFrame.destinationEndpoint,
+                linkquality: lastHopLqi,
+                groupID: apsFrame.groupId,
+                wasBroadcast: false,
+                destinationEndpoint: apsFrame.sourceEndpoint,
+            } as ZclPayload);
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: sendZclFrameToEndpoint without response", async () => {
+            const networkAddress: NodeId = 1234;
+            const endpoint: number = 3;
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+
+            const p = adapter.sendZclFrameToEndpoint("0x1122334455667788", networkAddress, endpoint, zclFrame, 10000, true, false, sourceEndpoint);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual(undefined);
+
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS & ~EmberApsOption.RETRY,
+                groupId: 0,
+                sequence: 0, // set by stack
+            };
+
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.DIRECT, networkAddress, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: sendZclFrameToGroup with source endpoint", async () => {
+            const groupId: number = 32;
+            const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});
+            const p = adapter.sendZclFrameToGroup(groupId, zclFrame, 2);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual(undefined);
+
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint: 2,
+                destinationEndpoint: 0xff,
+                options: DEFAULT_APS_OPTIONS,
+                groupId,
+                sequence: 0, // set by stack
+            };
+
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.MULTICAST, groupId, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: sendZclFrameToGroup with default source endpoint", async () => {
+            const groupId: number = 32;
+            const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});
+            const p = adapter.sendZclFrameToGroup(groupId, zclFrame);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual(undefined);
+
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint: FIXED_ENDPOINTS[0].endpoint,
+                destinationEndpoint: 0xff,
+                options: DEFAULT_APS_OPTIONS,
+                groupId,
+                sequence: 0, // set by stack
+            };
+
+            expect(mockEzspSend).toHaveBeenCalledWith(EmberOutgoingMessageType.MULTICAST, groupId, apsFrame, zclFrame.toBuffer(), 0, 0);
+        });
+
+        it("Adapter impl: throws when sendZclFrameToGroup fails request", async () => {
+            mockEzspSend.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            const groupId: number = 32;
+            const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});
+            const p = defuseRejection(adapter.sendZclFrameToGroup(groupId, zclFrame, 1));
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).rejects.toThrow("~x~> [ZCL GROUP groupId=32] Failed to send with status=FAIL.");
+            expect(mockEzspSend).toHaveBeenCalledTimes(1);
+        });
+
+        it("Adapter impl: sendZclFrameToAll with fixed endpoint", async () => {
+            const endpoint: number = 32;
+            const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});
+            const sourceEndpoint = FIXED_ENDPOINTS[0].endpoint;
+            const p = adapter.sendZclFrameToAll(endpoint, zclFrame, sourceEndpoint, ZSpec.BroadcastAddress.DEFAULT);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual(undefined);
+
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: ZSpec.BroadcastAddress.DEFAULT,
+                sequence: 0, // set by stack
+            };
+
+            expect(mockEzspSend).toHaveBeenCalledWith(
+                EmberOutgoingMessageType.BROADCAST,
+                ZSpec.BroadcastAddress.DEFAULT,
+                apsFrame,
+                zclFrame.toBuffer(),
+                0,
+                0,
+            );
+        });
+
+        it("Adapter impl: sendZclFrameToAll with other endpoint", async () => {
+            const endpoint: number = 32;
+            const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});
+            const sourceEndpoint = 3;
+            const p = adapter.sendZclFrameToAll(endpoint, zclFrame, sourceEndpoint, ZSpec.BroadcastAddress.DEFAULT);
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).resolves.toStrictEqual(undefined);
+
+            const apsFrame: EmberApsFrame = {
+                profileId: FIXED_ENDPOINTS[0].profileId,
+                clusterId: zclFrame.cluster.ID,
+                sourceEndpoint,
+                destinationEndpoint: endpoint,
+                options: DEFAULT_APS_OPTIONS,
+                groupId: ZSpec.BroadcastAddress.DEFAULT,
+                sequence: 0, // set by stack
+            };
+
+            expect(mockEzspSend).toHaveBeenCalledWith(
+                EmberOutgoingMessageType.BROADCAST,
+                ZSpec.BroadcastAddress.DEFAULT,
+                apsFrame,
+                zclFrame.toBuffer(),
+                0,
+                0,
+            );
+        });
+
+        it("Adapter impl: throws when sendZclFrameToAll fails request", async () => {
+            mockEzspSend.mockResolvedValueOnce([SLStatus.FAIL, 0]);
+
+            const endpoint: number = 32;
+            const zclFrame = Zcl.Frame.create(Zcl.FrameType.GLOBAL, Zcl.Direction.SERVER_TO_CLIENT, true, undefined, 1, 1, 0, [{}], {});
+            const p = defuseRejection(adapter.sendZclFrameToAll(endpoint, zclFrame, 1, ZSpec.BroadcastAddress.DEFAULT));
+
+            await vi.advanceTimersByTimeAsync(5000);
+            await expect(p).rejects.toThrow("~x~> [ZCL BROADCAST destination=65532] Failed to send with status=FAIL.");
+            expect(mockEzspSend).toHaveBeenCalledTimes(1);
+        });
+
+        it("Adapter impl: setChannelInterPAN", async () => {
+            await expect(adapter.setChannelInterPAN(15)).resolves.toStrictEqual(undefined);
+            expect(mockEzspSetLogicalAndRadioChannel).toHaveBeenCalledWith(15);
+        });
+
+        it("Adapter impl: throws when setChannelInterPAN fails request", async () => {
+            mockEzspSetLogicalAndRadioChannel.mockResolvedValueOnce(SLStatus.FAIL);
+
+            await expect(adapter.setChannelInterPAN(15)).rejects.toThrow(`Failed to set InterPAN channel to '15' with status=FAIL.`);
+            expect(mockEzspSetLogicalAndRadioChannel).toHaveBeenCalledWith(15);
+        });
+
+        it("Adapter impl: sendZclFrameInterPANToIeeeAddr", async () => {
+            const ieee: Eui64 = "0x1122334455667788";
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                false,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+
+            await expect(adapter.sendZclFrameInterPANToIeeeAddr(zclFrame, ieee)).resolves.toStrictEqual(undefined);
+            expect(mockEzspSendRawMessage).toHaveBeenCalledTimes(1);
+            expect(mockEzspSendRawMessage).toHaveBeenCalledWith(expect.any(Buffer), 1, true);
+        });
+
+        it("Adapter impl: throws when sendZclFrameInterPANToIeeeAddr request fails", async () => {
+            mockEzspSendRawMessage.mockResolvedValueOnce(SLStatus.BUSY);
+
+            const ieee: Eui64 = "0x1122334455667788";
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                false,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+
+            await expect(adapter.sendZclFrameInterPANToIeeeAddr(zclFrame, ieee)).rejects.toThrow(
+                `~x~> [ZCL TOUCHLINK to=${ieee}] Failed to send with status=${SLStatus[SLStatus.BUSY]}.`,
+            );
+            expect(mockEzspSendRawMessage).toHaveBeenCalledTimes(1);
+            expect(mockEzspSendRawMessage).toHaveBeenCalledWith(expect.any(Buffer), 1, true);
+        });
+
+        it("Adapter impl: sendZclFrameInterPANBroadcast", async () => {
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.SPECIFIC,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                true,
+                undefined,
+                0,
+                "scanRequest",
+                Zcl.Clusters.touchlink.ID,
+                {transactionID: 1, zigbeeInformation: 4, touchlinkInformation: 18},
+                {},
+            );
+            const sourcePanId: PanId = 0x1234;
+            const sourceAddress: Eui64 = "0x1122334455aabbcc";
+            const groupId: number = ZSpec.BroadcastAddress.SLEEPY;
+            const lastHopLqi = 252;
+            // Received Zigbee message from '0x', type 'readResponse', cluster 'genBasic', data '{"zclVersion":3}' from endpoint 1 with groupID 0
+            const messageContents = Buffer.from("1800010000000100000000000000000088776655443322110154466341200", "hex");
+
+            mockEzspSendRawMessage.mockImplementationOnce(() => {
+                setTimeout(async () => {
+                    mockEzspEmitter.emit("touchlinkMessage", sourcePanId, sourceAddress, groupId, lastHopLqi, messageContents);
+                    await flushPromises();
+                }, 300);
+
+                return SLStatus.OK;
+            });
+
+            const p = adapter.sendZclFrameInterPANBroadcast(zclFrame, 10000, false);
+
+            await vi.advanceTimersByTimeAsync(5000);
+
+            const payload: ZclPayload = {
+                clusterID: Zcl.Clusters.touchlink.ID,
+                header: Zcl.Header.fromBuffer(messageContents),
+                address: sourceAddress,
+                data: messageContents,
+                endpoint: FIXED_ENDPOINTS[0].endpoint,
+                linkquality: lastHopLqi,
+                groupID: groupId,
+                wasBroadcast: true,
+                destinationEndpoint: FIXED_ENDPOINTS[0].endpoint,
+            };
+
+            await expect(p).resolves.toStrictEqual(payload);
+            expect(mockEzspSendRawMessage).toHaveBeenCalledTimes(1);
+            expect(mockEzspSendRawMessage).toHaveBeenCalledWith(expect.any(Buffer), 1, true);
+        });
+
+        it("Adapter impl: throws when sendZclFrameInterPANBroadcast command has no response", async () => {
+            const commandName = "readRsp";
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                false,
+                undefined,
+                3,
+                commandName,
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+
+            await expect(adapter.sendZclFrameInterPANBroadcast(zclFrame, 10000, false)).rejects.toThrow(
+                `Command '${commandName}' has no response, cannot wait for response.`,
+            );
+            expect(mockEzspSendRawMessage).toHaveBeenCalledTimes(0);
+        });
+
+        it("Adapter impl: throws when sendZclFrameInterPANBroadcast request fails", async () => {
+            mockEzspSendRawMessage.mockResolvedValueOnce(SLStatus.BUSY);
+
+            const zclFrame = Zcl.Frame.create(
+                Zcl.FrameType.GLOBAL,
+                Zcl.Direction.CLIENT_TO_SERVER,
+                false,
+                undefined,
+                3,
+                "read",
+                "genBasic",
+                [{attrId: 0}],
+                {},
+            );
+
+            await expect(adapter.sendZclFrameInterPANBroadcast(zclFrame, 10000, false)).rejects.toThrow(
+                `~x~> [ZCL TOUCHLINK BROADCAST] Failed to send with status=${SLStatus[SLStatus.BUSY]}.`,
+            );
+            expect(mockEzspSendRawMessage).toHaveBeenCalledTimes(1);
+            expect(mockEzspSendRawMessage).toHaveBeenCalledWith(expect.any(Buffer), 1, true);
+        });
+
+        it("Adapter impl: restoreChannelInterPAN", async () => {
+            const p = adapter.restoreChannelInterPAN();
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).resolves.toStrictEqual(undefined);
+            expect(mockEzspSetLogicalAndRadioChannel).toHaveBeenCalledWith(DEFAULT_NETWORK_OPTIONS.channelList[0]);
+        });
+
+        it("Adapter impl: throws when restoreChannelInterPAN fails request", async () => {
+            mockEzspSetLogicalAndRadioChannel.mockResolvedValueOnce(SLStatus.FAIL);
+
+            const p = defuseRejection(adapter.restoreChannelInterPAN());
+
+            await vi.advanceTimersByTimeAsync(10000);
+            await expect(p).rejects.toThrow(`Failed to restore InterPAN channel to '${DEFAULT_NETWORK_OPTIONS.channelList[0]}' with status=FAIL.`);
+            expect(mockEzspSetLogicalAndRadioChannel).toHaveBeenCalledWith(DEFAULT_NETWORK_OPTIONS.channelList[0]);
+        });
+    });
+});