zigbee-herdsman 4.3.2 → 4.4.1

package/src/zspec/utils.ts

@@ -1,5 +1,5 @@
 import {createCipheriv} from "node:crypto";
-import {AES_MMO_128_BLOCK_SIZE, ALL_802_15_4_CHANNELS, INSTALL_CODE_CRC_SIZE, INSTALL_CODE_SIZES} from "./consts";
+import {AES_MMO_128_BLOCK_SIZE, ALL_802_15_4_CHANNELS} from "./consts";
 import {BroadcastAddress} from "./enums";
 import type {Eui64} from "./tstypes";
 
@@ -245,62 +245,3 @@ export function aes128MmoHash(data: Buffer): Buffer {
 
     return result;
 }
-
-/**
- * Check if install code (little-endian) is valid, and if not, and requested, fix it.
- *
- * WARNING: Due to conflicting sizes between 8-length code with invalid CRC, and 10-length code missing CRC, given 8-length codes are always assumed to be 8-length code with invalid CRC (most probable scenario).
- *
- * @param code The code to check. Reference is not modified by this procedure but is returned when code was valid, as `outCode`.
- * @param adjust If false, throws if the install code is invalid, otherwise try to fix it (CRC)
- * @returns
- *   - The adjusted code, or `code` if not adjusted.
- *   - If adjust is false, undefined, otherwise, the reason why the code needed adjusting or undefined if not.
- *   - Throws when adjust=false and invalid, or cannot fix.
- */
-export function checkInstallCode(code: Buffer, adjust = true): [outCode: Buffer, adjusted: "invalid CRC" | "missing CRC" | undefined] {
-    const crcLowByteIndex = code.length - INSTALL_CODE_CRC_SIZE;
-    const crcHighByteIndex = code.length - INSTALL_CODE_CRC_SIZE + 1;
-
-    for (const codeSize of INSTALL_CODE_SIZES) {
-        if (code.length === codeSize) {
-            // install code has CRC, check if valid, if not, replace it
-            const crc = crc16X25(code.subarray(0, -2));
-            const crcHighByte = (crc >> 8) & 0xff;
-            const crcLowByte = crc & 0xff;
-
-            if (code[crcLowByteIndex] !== crcLowByte || code[crcHighByteIndex] !== crcHighByte) {
-                // see WARNING above, 8 is smallest valid length, so always ends up here
-                if (adjust) {
-                    const outCode = Buffer.from(code);
-                    outCode[crcLowByteIndex] = crcLowByte;
-                    outCode[crcHighByteIndex] = crcHighByte;
-
-                    return [outCode, "invalid CRC"];
-                }
-
-                throw new Error(`Install code ${code.toString("hex")} failed CRC validation`);
-            }
-
-            return [code, undefined];
-        }
-
-        if (code.length === codeSize - INSTALL_CODE_CRC_SIZE) {
-            if (adjust) {
-                // install code is missing CRC
-                const crc = crc16X25(code);
-                const outCode = Buffer.alloc(code.length + INSTALL_CODE_CRC_SIZE);
-
-                code.copy(outCode, 0);
-                outCode.writeUInt16LE(crc, code.length);
-
-                return [outCode, "missing CRC"];
-            }
-
-            throw new Error(`Install code ${code.toString("hex")} failed CRC validation`);
-        }
-    }
-
-    // never returned from within the above loop
-    throw new Error(`Install code ${code.toString("hex")} has invalid size`);
-}

package/src/zspec/zcl/definition/cluster.ts

@@ -1992,6 +1992,9 @@ export const Clusters: Readonly<Record<ClusterName, Readonly<ClusterDefinition>>
             danfossRoomFloorSensorMode: {ID: 0x4120, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossFloorMinSetpoint: {ID: 0x4121, type: DataType.INT16, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossFloorMaxSetpoint: {ID: 0x4122, type: DataType.INT16, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossScheduleTypeUsed: {ID: 0x4130, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIcon2PreHeat: {ID: 0x4131, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIcon2PreHeatStatus: {ID: 0x414f, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             elkoLoad: {ID: 0x0401, type: DataType.UINT16},
             elkoDisplayText: {ID: 0x0402, type: DataType.CHAR_STR},
             elkoSensor: {ID: 0x0403, type: DataType.ENUM8},
@@ -4280,8 +4283,11 @@ export const Clusters: Readonly<Record<ClusterName, Readonly<ClusterDefinition>>
             lastMessageLqi: {ID: 284, type: DataType.UINT8},
             lastMessageRssi: {ID: 285, type: DataType.INT8},
             danfossSystemStatusCode: {ID: 0x4000, type: DataType.BITMAP16, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossHeatSupplyRequest: {ID: 0x4031, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossSystemStatusWater: {ID: 0x4200, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             danfossMultimasterRole: {ID: 0x4201, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIconApplication: {ID: 0x4210, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
+            danfossIconForcedHeatingCooling: {ID: 0x4220, type: DataType.ENUM8, manufacturerCode: ManufacturerCode.DANFOSS_A_S},
             schneiderMeterStatus: {ID: 0xff01, type: DataType.UINT32, manufacturerCode: ManufacturerCode.SCHNEIDER_ELECTRIC},
             schneiderDiagnosticRegister1: {ID: 0xff02, type: DataType.UINT32, manufacturerCode: ManufacturerCode.SCHNEIDER_ELECTRIC},
             schneiderCommunicationQuality: {ID: 0x4000, type: DataType.UINT8, manufacturerCode: ManufacturerCode.SCHNEIDER_ELECTRIC},

package/test/controller.test.ts

@@ -1839,7 +1839,7 @@ describe("Controller", () => {
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x9035EAFFFE424783",
+            "0x9035eafffe424783",
             Buffer.from([0xae, 0x3b, 0x28, 0x72, 0x81, 0xcf, 0x16, 0xf5, 0x50, 0x73, 0x3a, 0x0c, 0xec, 0x38, 0xaa, 0x31, 0xe8, 0x02]),
             false,
         );
@@ -1851,37 +1851,102 @@ describe("Controller", () => {
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(2);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x000D6F00179F2BC9",
+            "0x000d6f00179f2bc9",
             Buffer.from([0xd0, 0xf4, 0x71, 0xc9, 0xbb, 0xa2, 0xc0, 0x20, 0x86, 0x08, 0xe9, 0x1e, 0xed, 0x17, 0xe2, 0xb1, 0x9a, 0xec]),
             false,
         );
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x000D6F00179F2BC9",
+            "0x000d6f00179f2bc9",
             Buffer.from([0xd0, 0xf4, 0x71, 0xc9, 0xbb, 0xa2, 0xc0, 0x20, 0x86, 0x08, 0xe9, 0x1e, 0xed, 0x17, 0xe2, 0xb1]),
             true,
         );
         expect(mockLogger.info).toHaveBeenCalledWith(`Install code was adjusted for reason 'missing CRC'.`, "zh:controller");
     });
 
+    it("Add install code widely adopted format", async () => {
+        await controller.start();
+        // inovelli
+        const code = "Z:6C5CB1FFFE44FDFD$I:5492072F8DE72829FEE139CF8ACA4F43EF21";
+        await controller.addInstallCode(code);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            1,
+            "0x6c5cb1fffe44fdfd",
+            Buffer.from([
+                0x54, 0x92, 0x07, 0x2f, 0x8d, 0xe7, 0x28, 0x29, 0xfe, 0xe1, 0x39, 0xcf, 0x8a, 0xca, 0x4f, 0x43, /*0xef, 0x21 bad CRC?*/ 0x85, 0x44,
+            ]),
+            false,
+        );
+        // danfoss
+        const code2 = "G$M:IC2%Z:540F57FFFE599FAA$I:D79CB21C6D197CE7A3339A683A90DFF2442A%M:1246";
+        await controller.addInstallCode(code2);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            2,
+            "0x540f57fffe599faa",
+            Buffer.from([0xd7, 0x9c, 0xb2, 0x1c, 0x6d, 0x19, 0x7c, 0xe7, 0xa3, 0x33, 0x9a, 0x68, 0x3a, 0x90, 0xdf, 0xf2, 0x44, 0x2a]),
+            false,
+        );
+        // ??
+        const code3 = "Z:4CC206FFFE306C43$I:150A1A57D11A1A01362622DBA97ACF0F9185$D:202%B:4CC206306C43$P:983639%M:1220$F:002D";
+        await controller.addInstallCode(code3);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            3,
+            "0x4cc206fffe306c43",
+            Buffer.from([
+                0x15, 0x0a, 0x1a, 0x57, 0xd1, 0x1a, 0x1a, 0x01, 0x36, 0x26, 0x22, 0xdb, 0xa9, 0x7a, 0xcf, 0x0f, /*0x91, 0x85 bad CRC?*/ 0x0c, 0xca,
+            ]),
+            false,
+        );
+        // ubisys
+        const code4 = "Z:0102030405060708$I:0102030405060708090A0B0C0D0E0F1090FD%G$M:S1-R%M:10F2";
+        await controller.addInstallCode(code4);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            4,
+            "0x0102030405060708",
+            Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x90, 0xfd]),
+            false,
+        );
+        // ledvance
+        const code5 = "Z:F0D1B8000017389A$I:6AB6973274EE6F720200530162754044C930%M:1189$D:008B452720";
+        await controller.addInstallCode(code5);
+        expect(mockAddInstallCode).toHaveBeenNthCalledWith(
+            5,
+            "0xf0d1b8000017389a",
+            Buffer.from([0x6a, 0xb6, 0x97, 0x32, 0x74, 0xee, 0x6f, 0x72, 0x02, 0x00, 0x53, 0x01, 0x62, 0x75, 0x40, 0x44, 0xc9, 0x30]),
+            false,
+        );
+    });
+
     it("Add install code Aqara", async () => {
         await controller.start();
         const code = "G$M:69775$S:680S00003915$D:0000000017B2335C%Z$A:54EF44100006E7DF$I:3313A005E177A647FC7925620AB207C4BEF5";
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x54EF44100006E7DF",
+            "0x54ef44100006e7df",
             Buffer.from([0x33, 0x13, 0xa0, 0x05, 0xe1, 0x77, 0xa6, 0x47, 0xfc, 0x79, 0x25, 0x62, 0x0a, 0xb2, 0x07, 0xc4, 0xbe, 0xf5]),
             false,
         );
     });
 
+    it("Add install code Hue", async () => {
+        await controller.start();
+        const code = "HUE:Z:0123456789ABCDEF0123456789ABCDEF0123 M:0123456789ABCDEF D:L3B A:1184";
+        await controller.addInstallCode(code);
+        expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
+        expect(mockAddInstallCode).toHaveBeenCalledWith(
+            "0x0123456789abcdef",
+            Buffer.from([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xe7, 0xb8]),
+            false,
+        );
+    });
+
     it("Add install code pipe", async () => {
         await controller.start();
         const code = "54EF44100006E7DF|3313A005E177A647FC7925620AB207C4BEF5";
         await controller.addInstallCode(code);
         expect(mockAddInstallCode).toHaveBeenCalledTimes(1);
         expect(mockAddInstallCode).toHaveBeenCalledWith(
-            "0x54EF44100006E7DF",
+            "0x54ef44100006e7df",
             Buffer.from([0x33, 0x13, 0xa0, 0x05, 0xe1, 0x77, 0xa6, 0x47, 0xfc, 0x79, 0x25, 0x62, 0x0a, 0xb2, 0x07, 0xc4, 0xbe, 0xf5]),
             false,
         );
@@ -1897,6 +1962,18 @@ describe("Controller", () => {
         expect(mockAddInstallCode).toHaveBeenCalledTimes(0);
     });
 
+    it("Add install code unknown format", async () => {
+        await controller.start();
+
+        const code = "54EF44100006E7DF`3313A005E177A647FC7925620AB207";
+
+        await expect(controller.addInstallCode(code)).rejects.toThrow(
+            "Unsupported install code, got 47 chars, expected 95 or 91 chars, or known format",
+        );
+
+        expect(mockAddInstallCode).toHaveBeenCalledTimes(0);
+    });
+
     it("Controller permit joining all, disabled automatically", async () => {
         await controller.start();
 

package/test/utils.test.ts

@@ -1,3 +1,4 @@
+import {checkInstallCode} from "../src/controller/helpers/installCodes";
 import {Queue, Utils, Waitress, wait} from "../src/utils";
 import {logger, setLogger} from "../src/utils/logger";
 
@@ -133,14 +134,14 @@ describe("Utils", () => {
 
     it("Test queue", async () => {
         const queue = new Queue(4);
-        const finished = [];
+        const finished: number[] = [];
 
-        let job1Promise;
-        let job2Promise;
-        const job1 = new Promise((resolve) => {
+        let job1Promise: (() => void) | undefined;
+        let job2Promise: (() => void) | undefined;
+        const job1 = new Promise<void>((resolve) => {
             job1Promise = resolve;
         });
-        const job2 = new Promise((resolve) => {
+        const job2 = new Promise<void>((resolve) => {
             job2Promise = resolve;
         });
         const job5 = new Promise((_resolve) => {});
@@ -189,11 +190,11 @@ describe("Utils", () => {
         });
 
         expect(finished).toEqual([4]);
-        job1Promise();
+        job1Promise?.();
         expect(await job1Result).toBe("finished");
         await job1Result;
         expect(finished).toEqual([4, 1]);
-        job2Promise();
+        job2Promise?.();
         await job2Result;
         expect(finished).toEqual([4, 1, 2, 3]);
         expect(queue.count()).toBe(5);
@@ -224,4 +225,54 @@ describe("Utils", () => {
         logger.error("error", "zh");
         expect(mockLogger.error).toHaveBeenCalledWith("error", "zh");
     });
+
+    it("Checks install codes of all lengths", () => {
+        expect(() => checkInstallCode(Buffer.from("001122", "hex"))).toThrow("Install code 001122 has invalid size");
+
+        const code8Valid = Buffer.from("83FED3407A932B70", "hex");
+        const code8Invalid = Buffer.from("FFFED3407A939723", "hex");
+        const code8InvalidFixed = Buffer.from("FFFED3407A93DE84", "hex");
+        const code8MissingCRC = Buffer.from("83FED3407A93", "hex");
+
+        expect(checkInstallCode(code8Valid)).toStrictEqual([code8Valid, undefined]);
+        expect(checkInstallCode(code8Invalid)).toStrictEqual([code8InvalidFixed, "invalid CRC"]);
+        expect(() => checkInstallCode(code8Invalid, false)).toThrow(`Install code ${code8Invalid.toString("hex")} failed CRC validation`);
+        expect(checkInstallCode(code8MissingCRC)).toStrictEqual([code8Valid, "missing CRC"]);
+        expect(() => checkInstallCode(code8MissingCRC, false)).toThrow(`Install code ${code8MissingCRC.toString("hex")} failed CRC validation`);
+
+        const code10Valid = Buffer.from("83FED3407A93972397FC", "hex");
+        const code10Invalid = Buffer.from("FFFED3407A939723A5C6", "hex");
+        const code10InvalidFixed = Buffer.from("FFFED3407A9397238C4F", "hex");
+        // consired as 8-length with invalid CRC
+        const code10MissingCRC = Buffer.from("83FED3407A939723", "hex");
+        const code10MissingCRCFixed = Buffer.from("83FED3407A932B70", "hex");
+
+        expect(checkInstallCode(code10Valid)).toStrictEqual([code10Valid, undefined]);
+        expect(checkInstallCode(code10Invalid)).toStrictEqual([code10InvalidFixed, "invalid CRC"]);
+        expect(() => checkInstallCode(code10Invalid, false)).toThrow(`Install code ${code10Invalid.toString("hex")} failed CRC validation`);
+        expect(checkInstallCode(code10MissingCRC)).toStrictEqual([code10MissingCRCFixed, "invalid CRC"]);
+        expect(() => checkInstallCode(code10MissingCRC, false)).toThrow(`Install code ${code10MissingCRC.toString("hex")} failed CRC validation`);
+
+        const code14Valid = Buffer.from("83FED3407A939723A5C639FF4C12", "hex");
+        const code14Invalid = Buffer.from("FFFED3407A939723A5C639FF4C12", "hex");
+        const code14InvalidFixed = Buffer.from("FFFED3407A939723A5C639FFDE74", "hex");
+        const code14MissingCRC = Buffer.from("83FED3407A939723A5C639FF", "hex");
+
+        expect(checkInstallCode(code14Valid)).toStrictEqual([code14Valid, undefined]);
+        expect(checkInstallCode(code14Invalid)).toStrictEqual([code14InvalidFixed, "invalid CRC"]);
+        expect(() => checkInstallCode(code14Invalid, false)).toThrow(`Install code ${code14Invalid.toString("hex")} failed CRC validation`);
+        expect(checkInstallCode(code14MissingCRC)).toStrictEqual([code14Valid, "missing CRC"]);
+        expect(() => checkInstallCode(code14MissingCRC, false)).toThrow(`Install code ${code14MissingCRC.toString("hex")} failed CRC validation`);
+
+        const code18Valid = Buffer.from("83FED3407A939723A5C639B26916D505C3B5", "hex");
+        const code18Invalid = Buffer.from("FFFED3407A939723A5C639B26916D505C3B5", "hex");
+        const code18InvalidFixed = Buffer.from("FFFED3407A939723A5C639B26916D505EEB1", "hex");
+        const code18MissingCRC = Buffer.from("83FED3407A939723A5C639B26916D505", "hex");
+
+        expect(checkInstallCode(code18Valid)).toStrictEqual([code18Valid, undefined]);
+        expect(checkInstallCode(code18Invalid)).toStrictEqual([code18InvalidFixed, "invalid CRC"]);
+        expect(() => checkInstallCode(code18Invalid, false)).toThrow(`Install code ${code18Invalid.toString("hex")} failed CRC validation`);
+        expect(checkInstallCode(code18MissingCRC)).toStrictEqual([code18Valid, "missing CRC"]);
+        expect(() => checkInstallCode(code18MissingCRC, false)).toThrow(`Install code ${code18MissingCRC.toString("hex")} failed CRC validation`);
+    });
 });

package/test/zspec/utils.test.ts

@@ -64,68 +64,4 @@ describe("ZSpec Utils", () => {
         expect(ZSpec.Utils.aes128MmoHash(val3)).toStrictEqual(Buffer.from("3C3D537529A7A9A03F669DCD886CB52C", "hex"));
         expect(ZSpec.Utils.aes128MmoHash(val4)).toStrictEqual(Buffer.from("4512807BF94CB3400F0E2C25FB76E999", "hex"));
     });
-
-    it("Checks install codes of all lengths", () => {
-        expect(() => ZSpec.Utils.checkInstallCode(Buffer.from("001122", "hex"))).toThrow("Install code 001122 has invalid size");
-
-        const code8Valid = Buffer.from("83FED3407A932B70", "hex");
-        const code8Invalid = Buffer.from("FFFED3407A939723", "hex");
-        const code8InvalidFixed = Buffer.from("FFFED3407A93DE84", "hex");
-        const code8MissingCRC = Buffer.from("83FED3407A93", "hex");
-
-        expect(ZSpec.Utils.checkInstallCode(code8Valid)).toStrictEqual([code8Valid, undefined]);
-        expect(ZSpec.Utils.checkInstallCode(code8Invalid)).toStrictEqual([code8InvalidFixed, "invalid CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code8Invalid, false)).toThrow(`Install code ${code8Invalid.toString("hex")} failed CRC validation`);
-        expect(ZSpec.Utils.checkInstallCode(code8MissingCRC)).toStrictEqual([code8Valid, "missing CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code8MissingCRC, false)).toThrow(
-            `Install code ${code8MissingCRC.toString("hex")} failed CRC validation`,
-        );
-
-        const code10Valid = Buffer.from("83FED3407A93972397FC", "hex");
-        const code10Invalid = Buffer.from("FFFED3407A939723A5C6", "hex");
-        const code10InvalidFixed = Buffer.from("FFFED3407A9397238C4F", "hex");
-        // consired as 8-length with invalid CRC
-        const code10MissingCRC = Buffer.from("83FED3407A939723", "hex");
-        const code10MissingCRCFixed = Buffer.from("83FED3407A932B70", "hex");
-
-        expect(ZSpec.Utils.checkInstallCode(code10Valid)).toStrictEqual([code10Valid, undefined]);
-        expect(ZSpec.Utils.checkInstallCode(code10Invalid)).toStrictEqual([code10InvalidFixed, "invalid CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code10Invalid, false)).toThrow(
-            `Install code ${code10Invalid.toString("hex")} failed CRC validation`,
-        );
-        expect(ZSpec.Utils.checkInstallCode(code10MissingCRC)).toStrictEqual([code10MissingCRCFixed, "invalid CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code10MissingCRC, false)).toThrow(
-            `Install code ${code10MissingCRC.toString("hex")} failed CRC validation`,
-        );
-
-        const code14Valid = Buffer.from("83FED3407A939723A5C639FF4C12", "hex");
-        const code14Invalid = Buffer.from("FFFED3407A939723A5C639FF4C12", "hex");
-        const code14InvalidFixed = Buffer.from("FFFED3407A939723A5C639FFDE74", "hex");
-        const code14MissingCRC = Buffer.from("83FED3407A939723A5C639FF", "hex");
-
-        expect(ZSpec.Utils.checkInstallCode(code14Valid)).toStrictEqual([code14Valid, undefined]);
-        expect(ZSpec.Utils.checkInstallCode(code14Invalid)).toStrictEqual([code14InvalidFixed, "invalid CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code14Invalid, false)).toThrow(
-            `Install code ${code14Invalid.toString("hex")} failed CRC validation`,
-        );
-        expect(ZSpec.Utils.checkInstallCode(code14MissingCRC)).toStrictEqual([code14Valid, "missing CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code14MissingCRC, false)).toThrow(
-            `Install code ${code14MissingCRC.toString("hex")} failed CRC validation`,
-        );
-
-        const code18Valid = Buffer.from("83FED3407A939723A5C639B26916D505C3B5", "hex");
-        const code18Invalid = Buffer.from("FFFED3407A939723A5C639B26916D505C3B5", "hex");
-        const code18InvalidFixed = Buffer.from("FFFED3407A939723A5C639B26916D505EEB1", "hex");
-        const code18MissingCRC = Buffer.from("83FED3407A939723A5C639B26916D505", "hex");
-
-        expect(ZSpec.Utils.checkInstallCode(code18Valid)).toStrictEqual([code18Valid, undefined]);
-        expect(ZSpec.Utils.checkInstallCode(code18Invalid)).toStrictEqual([code18InvalidFixed, "invalid CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code18Invalid, false)).toThrow(
-            `Install code ${code18Invalid.toString("hex")} failed CRC validation`,
-        );
-        expect(ZSpec.Utils.checkInstallCode(code18MissingCRC)).toStrictEqual([code18Valid, "missing CRC"]);
-        expect(() => ZSpec.Utils.checkInstallCode(code18MissingCRC, false)).toThrow(
-            `Install code ${code18MissingCRC.toString("hex")} failed CRC validation`,
-        );
-    });
 });