3232060682

Build # 3232060682

Build Type

github

Committed by GitHub

Commit Message

Merge 65e045e82 into 0ed9dcad2

Pull Request Pull Request #973: Improve test coverage

Run Details

1498 of 3527 branches covered (42.47%)

Branch coverage included in aggregate %.

66 of 75 new or added lines in 10 files covered. (88.0%)

1 existing line in 1 file now uncovered.

6283 of 10121 relevant lines covered (62.08%)

49.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.12

/src/lib/util/tlv.ts

import assert from "assert";
import * as hapCrypto from "../util/hapCrypto";

/**
 * Type Length Value encoding/decoding, used by HAP as a wire format.
 * https://en.wikipedia.org/wiki/Type-length-value
 */

const EMPTY_TLV_TYPE = 0x00; // and empty tlv with id 0 is usually used as delimiter for tlv lists

export type TLVEncodable = Buffer | number | string;

// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function encode(type: number, data: TLVEncodable | TLVEncodable[], ...args: any[]): Buffer {
  const encodedTLVBuffers: Buffer[] = [];

  // coerce data to Buffer if needed
  if (typeof data === "number") {
    data = Buffer.from([data]);
  } else if (typeof data === "string") {
    data = Buffer.from(data);
  }

  if (Array.isArray(data)) {
    let first = true;
    for (const entry of data) {
      if (!first) {
        encodedTLVBuffers.push(Buffer.from([EMPTY_TLV_TYPE, 0])); // push delimiter
      }

      first = false;
      encodedTLVBuffers.push(encode(type, entry));
    }

    if (first) { // we have a zero length array!
      encodedTLVBuffers.push(Buffer.from([type, 0]));
    }
  } else if (data.length <= 255) {
    encodedTLVBuffers.push(Buffer.concat([Buffer.from([type,data.length]),data]));
  } else { // otherwise it doesn't fit into one tlv entry, thus we push multiple
    let leftBytes = data.length;
    let currentIndex = 0;

    for (; leftBytes > 0;) {
      if (leftBytes >= 255) {
        encodedTLVBuffers.push(Buffer.concat([Buffer.from([type, 0xFF]), data.slice(currentIndex, currentIndex + 255)]));
        leftBytes -= 255;
        currentIndex += 255;
      } else {
        encodedTLVBuffers.push(Buffer.concat([Buffer.from([type,leftBytes]), data.slice(currentIndex)]));
        leftBytes -= leftBytes;
      }
    }
  }

  // do we have more arguments to encode?
  if (args.length >= 2) {

    // chop off the first two arguments which we already processed, and process the rest recursively
    const [ nextType, nextData, ...nextArgs ] = args;
    const remainingTLVBuffer = encode(nextType, nextData, ...nextArgs);

    // append the remaining encoded arguments directly to the buffer
    encodedTLVBuffers.push(remainingTLVBuffer);
  }

  return Buffer.concat(encodedTLVBuffers);
}

/**
 * This method is the legacy way of decoding tlv data.
 * It will not properly decode multiple list of the same id.
 * Should the decoder encounter multiple instances of the same id, it will just concatenate the buffer data.
 *
 * @param buffer - TLV8 data
 *
 * Note: Please use {@link decodeWithLists} which properly decodes list elements.
 */
export function decode(buffer: Buffer): Record<number, Buffer> {
  assert(buffer instanceof Buffer, "Illegal argument. tlv.decode() expects Buffer type!");
  const objects: Record<number, Buffer> = {};

  let leftLength = buffer.length;
  let currentIndex = 0;

  for (; leftLength > 0;) {
    const type = buffer[currentIndex];
    const length = buffer[currentIndex + 1];
    currentIndex += 2;
    leftLength -= 2;

    const data = buffer.slice(currentIndex, currentIndex + length);

    if (objects[type]) {
      objects[type] = Buffer.concat([objects[type],data]);
    } else {
      objects[type] = data;
    }

    currentIndex += length;
    leftLength -= length;
  }

  return objects;
}

/**
 * Decode a buffer coding TLV8 encoded entries.
 *
 * This method decodes multiple entries split by a TLV delimiter properly into Buffer arrays.
 * It properly reassembles tlv entries if they were split across multiple entries due to exceeding the max tlv entry size of 255 bytes.
 * @param buffer - The Buffer containing TLV8 encoded data.
 */
export function decodeWithLists(buffer: Buffer): Record<number, Buffer | Buffer[]> {
  const result: Record<number, Buffer | Buffer[]> = {};

  let leftBytes = buffer.length;
  let readIndex = 0;

  let lastType = -1;
  let lastLength = -1;
  let lastItemWasDelimiter = false;

  for (; leftBytes > 0;) {
    const type = buffer.readUInt8(readIndex++);
    const length = buffer.readUInt8(readIndex++);
    leftBytes -= 2;

    const data = buffer.slice(readIndex, readIndex + length);
    readIndex += length;
    leftBytes -= length;

    if (type === 0 && length === 0) {
      lastItemWasDelimiter = true;
      continue;
    }

    const existing = result[type];
    if (existing) { // there is already an item with the same type
      if (lastItemWasDelimiter && lastType === type) { // list of tlv types
        if (Array.isArray(existing)) {
          existing.push(data);
        } else {
          result[type] = [existing, data];
        }
      } else if (lastType === type && lastLength === 255) { // tlv data got split into multiple entries as length exceeded 255
        if (Array.isArray(existing)) {
          // append to the last data blob in the array
          const last = existing[existing.length - 1];
          existing[existing.length - 1] = Buffer.concat([last, data]);
        } else {
          result[type] = Buffer.concat([existing, data]);
        }
      } else {
        throw new Error(`Found duplicated tlv entry with type ${type} and length ${length} \
        (lastItemWasDelimiter: ${lastItemWasDelimiter}, lastType: ${lastType}, lastLength: ${lastLength})`);
      }
    } else {
      result[type] = data;
    }

    lastType = type;
    lastLength = length;
    lastItemWasDelimiter = false;
  }

  return result;
}

/**
 * This method can be used to parse a TLV8 encoded list that was concatenated.
 *
 * If you are thinking about using this method, try to refactor the code to use {@link decodeWithLists} instead of {@link decode}.
 * The single reason of this method's existence are the shortcomings {@link decode}, as it concatenates multiple tlv8 list entries
 * into a single Buffer.
 * This method can be used to undo that, by specifying the concatenated buffer and the tlv id of the element that should
 * mark the beginning of a new tlv8 list entry.
 *
 * @param data - The concatenated tlv8 list entries (probably output of {@link decode}).
 * @param entryStartId - The tlv id that marks the beginning of a new tlv8 entry.
 */
export function decodeList(data: Buffer, entryStartId: number): Record<number, Buffer>[] {
  const objectsList: Record<number, Buffer>[] = [];

  let leftLength = data.length;
  let currentIndex = 0;

  let objects: Record<number, Buffer> | undefined = undefined;

  for (; leftLength > 0;) {
    const type = data[currentIndex]; // T
    const length = data[currentIndex + 1]; // L
    const value = data.slice(currentIndex + 2, currentIndex + 2 + length); // V

    if (type === entryStartId) { // we got the start of a new entry
      if (objects !== undefined) { // save the previous entry
        objectsList.push(objects);
      }

      objects = {};
    }

    if (objects === undefined) {
      throw new Error("Error parsing tlv list: Encountered uninitialized storage object");
    }

    if (objects[type]) { // append to buffer if we have already data for this type
      objects[type] = Buffer.concat([objects[type], value]);
    } else {
      objects[type] = value;
    }

    currentIndex += 2 + length;
    leftLength -= 2 + length;
  }

  if (objects !== undefined) {
    objectsList.push(objects);
  } // push last entry

  return objectsList;
}

/**
 * @deprecated This implementation is considered broken. Don't use it.
 */
export function writeUInt64(value: number): Buffer {
  const float64 = new Float64Array(1);
  float64[0] = value;

  const buffer = Buffer.alloc(float64.buffer.byteLength);
  const view = new Uint8Array(float64.buffer);
  for (let i = 0; i < buffer.length; i++) {
    buffer[i] = view[i];
  }

  return buffer;
}

// noinspection JSUnusedGlobalSymbols
/**
 * @deprecated This implementation is considered broken. Don't use it.
 */
export function readUInt64(buffer: Buffer): number {
  const float64 = new Float64Array(buffer);
  return float64[0];
}

export function readUInt64LE(buffer: Buffer, offset = 0): number {
  const low = buffer.readUInt32LE(offset);
  // javascript doesn't allow to shift by 32(?), therefore we multiply here
  return buffer.readUInt32LE(offset + 4) * 0x100000000 + low;
}

// noinspection JSUnusedGlobalSymbols
/**
 * @deprecated The method was named wrongfully and actually reads an UInt64 in **little endian** format.
 */
export function readUInt64BE(buffer: Buffer, offset = 0): number {
  return readUInt64LE(buffer, offset);
}

/**
 * `writeUint32LE`
 */
export function writeUInt32(value: number): Buffer {
  const buffer = Buffer.alloc(4);

  buffer.writeUInt32LE(value, 0);

  return buffer;
}

/**
 * `readUInt32LE`
 */
export function readUInt32(buffer: Buffer): number {
  return buffer.readUInt32LE(0);
}

export function writeFloat32LE(value: number): Buffer {
  const buffer = Buffer.alloc(4);
  buffer.writeFloatLE(value, 0);
  return buffer;
}

/**
 * `writeUInt16LE`
 */
export function writeUInt16(value: number): Buffer {
  const buffer = Buffer.alloc(2);

  buffer.writeUInt16LE(value, 0);

  return buffer;
}

/**
 * `readUInt16LE`
 */
export function readUInt16(buffer: Buffer): number {
  return buffer.readUInt16LE(0);
}


/**
 * Reads variable size unsigned integer {@see writeVariableUIntLE}.
 * @param buffer - The buffer to read from. It must have exactly the size of the given integer.
 */
export function readVariableUIntLE(buffer: Buffer): number;
/**
 * @deprecated Can't define an offset. The original implementation messed up here!
 */
export function readVariableUIntLE(buffer: Buffer, offset: number): number;
export function readVariableUIntLE(buffer: Buffer, offset = 0): number {
  assert(offset === 0, "Can't define a offset different than 0!");

  switch (buffer.length) {
  case 1:
    return buffer.readUInt8(offset);
  case 2:
    return buffer.readUInt16LE(offset);
  case 4:
    return buffer.readUInt32LE(offset);
  case 8:
    return readUInt64LE(buffer, offset);
  default:
    throw new Error("Can't read uint LE with length " + buffer.length);
  }
}

/**
 * Writes variable size unsigned integer.
 * Either:
 * - `UInt8`
 * - `UInt16LE`
 * - `UInt32LE`
 * @param number
 */
export function writeVariableUIntLE(number: number, ): Buffer;
/**
 * @deprecated Can't define an offset. The original implementation messed up here!
 */
export function writeVariableUIntLE(number: number, offset: number): Buffer;
export function writeVariableUIntLE(number: number, offset = 0): Buffer {
  assert(number >= 0, "Can't encode a negative integer as unsigned integer");
  assert(offset === 0, "Can't define a offset different than 0!");

  if (number <= 255) {
    const buffer = Buffer.alloc(1);
    buffer.writeUInt8(number, offset);
    return buffer;
  } else if (number <= 65535) {
    return writeUInt16(number);
  } else if (number <= 4294967295) {
    return writeUInt32(number);
  } else {
    const buffer = Buffer.alloc(8);
    hapCrypto.writeUInt64LE(number, buffer, offset);
    return buffer;
  }
}

1	import assert from "assert";	33✔
2	import * as hapCrypto from "../util/hapCrypto";	33✔
3
4	/**
5	* Type Length Value encoding/decoding, used by HAP as a wire format.
6	* https://en.wikipedia.org/wiki/Type-length-value
7	*/
8
9	const EMPTY_TLV_TYPE = 0x00; // and empty tlv with id 0 is usually used as delimiter for tlv lists	33✔
10
11	export type TLVEncodable = Buffer \| number \| string;
12
13	// eslint-disable-next-line @typescript-eslint/no-explicit-any
14	export function encode(type: number, data: TLVEncodable \| TLVEncodable[], ...args: any[]): Buffer {	69,816✔
15	const encodedTLVBuffers: Buffer[] = [];	21,663✔
16
17	// coerce data to Buffer if needed
18	if (typeof data === "number") {	21,663✔
19	data = Buffer.from([data]);	4,740✔
20	} else if (typeof data === "string") {	16,923✔
21	data = Buffer.from(data);	9✔
22	}
23
24	if (Array.isArray(data)) {	21,663✔
25	let first = true;	1,791✔
26	for (const entry of data) {	5,958✔
27	if (!first) {	5,958✔
28	encodedTLVBuffers.push(Buffer.from([EMPTY_TLV_TYPE, 0])); // push delimiter	4,170✔
29	}
30
31	first = false;	5,958✔
32	encodedTLVBuffers.push(encode(type, entry));	5,958✔
33	}
34
35	if (first) { // we have a zero length array!	1,791✔
36	encodedTLVBuffers.push(Buffer.from([type, 0]));	3✔
37	}
38	} else if (data.length <= 255) {	19,872✔
39	encodedTLVBuffers.push(Buffer.concat([Buffer.from([type,data.length]),data]));	19,863✔
40	} else { // otherwise it doesn't fit into one tlv entry, thus we push multiple
41	let leftBytes = data.length;	9✔
42	let currentIndex = 0;	9✔
43
44	for (; leftBytes > 0;) {	9✔
45	if (leftBytes >= 255) {	21✔
46	encodedTLVBuffers.push(Buffer.concat([Buffer.from([type, 0xFF]), data.slice(currentIndex, currentIndex + 255)]));	12✔
47	leftBytes -= 255;	12✔
48	currentIndex += 255;	12✔
49	} else {
50	encodedTLVBuffers.push(Buffer.concat([Buffer.from([type,leftBytes]), data.slice(currentIndex)]));	9✔
51	leftBytes -= leftBytes;	9✔
52	}
53	}
54	}
55
56	// do we have more arguments to encode?
57	if (args.length >= 2) {	21,663✔
58
59	// chop off the first two arguments which we already processed, and process the rest recursively
60	const [ nextType, nextData, ...nextArgs ] = args;	9,069✔
61	const remainingTLVBuffer = encode(nextType, nextData, ...nextArgs);	9,069✔
62
63	// append the remaining encoded arguments directly to the buffer
64	encodedTLVBuffers.push(remainingTLVBuffer);	9,069✔
65	}
66
67	return Buffer.concat(encodedTLVBuffers);	21,663✔
68	}
69
70	/**
71	* This method is the legacy way of decoding tlv data.
72	* It will not properly decode multiple list of the same id.
73	* Should the decoder encounter multiple instances of the same id, it will just concatenate the buffer data.
74	*
75	* @param buffer - TLV8 data
76	*
77	* Note: Please use {@link decodeWithLists} which properly decodes list elements.
78	*/
79	export function decode(buffer: Buffer): Record<number, Buffer> {	33✔
80	assert(buffer instanceof Buffer, "Illegal argument. tlv.decode() expects Buffer type!");	51✔
81	const objects: Record<number, Buffer> = {};	51✔
82
83	let leftLength = buffer.length;	51✔
84	let currentIndex = 0;	51✔
85
86	for (; leftLength > 0;) {	51✔
87	const type = buffer[currentIndex];	123✔
88	const length = buffer[currentIndex + 1];	123✔
89	currentIndex += 2;	123✔
90	leftLength -= 2;	123✔
91
92	const data = buffer.slice(currentIndex, currentIndex + length);	123✔
93
94	if (objects[type]) {	123✔
95	objects[type] = Buffer.concat([objects[type],data]);	12✔
96	} else {
97	objects[type] = data;	111✔
98	}
99
100	currentIndex += length;	123✔
101	leftLength -= length;	123✔
102	}
103
104	return objects;	51✔
105	}
106
107	/**
108	* Decode a buffer coding TLV8 encoded entries.
109	*
110	* This method decodes multiple entries split by a TLV delimiter properly into Buffer arrays.
111	* It properly reassembles tlv entries if they were split across multiple entries due to exceeding the max tlv entry size of 255 bytes.
112	* @param buffer - The Buffer containing TLV8 encoded data.
113	*/
114	export function decodeWithLists(buffer: Buffer): Record<number, Buffer \| Buffer[]> {	33✔
115	const result: Record<number, Buffer \| Buffer[]> = {};	18✔
116
117	let leftBytes = buffer.length;	18✔
118	let readIndex = 0;	18✔
119
120	let lastType = -1;	18✔
121	let lastLength = -1;	18✔
122	let lastItemWasDelimiter = false;	18✔
123
124	for (; leftBytes > 0;) {	18✔
125	const type = buffer.readUInt8(readIndex++);	63✔
126	const length = buffer.readUInt8(readIndex++);	63✔
127	leftBytes -= 2;	63✔
128
129	const data = buffer.slice(readIndex, readIndex + length);	63✔
130	readIndex += length;	63✔
131	leftBytes -= length;	63✔
132
133	if (type === 0 && length === 0) {	63✔
134	lastItemWasDelimiter = true;	15✔
135	continue;	15✔
136	}
137
138	const existing = result[type];	48✔
139	if (existing) { // there is already an item with the same type	48✔
140	if (lastItemWasDelimiter && lastType === type) { // list of tlv types	24✔
141	if (Array.isArray(existing)) {	15✔
142	existing.push(data);	9✔
143	} else {
144	result[type] = [existing, data];	6✔
145	}
146	} else if (lastType === type && lastLength === 255) { // tlv data got split into multiple entries as length exceeded 255	9✔
147	if (Array.isArray(existing)) {	6✔
148	// append to the last data blob in the array
149	const last = existing[existing.length - 1];	3✔
150	existing[existing.length - 1] = Buffer.concat([last, data]);	3✔
151	} else {
152	result[type] = Buffer.concat([existing, data]);	3✔
153	}
154	} else {
155	throw new Error(`Found duplicated tlv entry with type ${type} and length ${length} \	3✔
156	(lastItemWasDelimiter: ${lastItemWasDelimiter}, lastType: ${lastType}, lastLength: ${lastLength})`);
157	}
158	} else {
159	result[type] = data;	24✔
160	}
161
162	lastType = type;	45✔
163	lastLength = length;	45✔
164	lastItemWasDelimiter = false;	45✔
165	}
166
167	return result;	15✔
168	}
169
170	/**
171	* This method can be used to parse a TLV8 encoded list that was concatenated.
172	*
173	* If you are thinking about using this method, try to refactor the code to use {@link decodeWithLists} instead of {@link decode}.
174	* The single reason of this method's existence are the shortcomings {@link decode}, as it concatenates multiple tlv8 list entries
175	* into a single Buffer.
176	* This method can be used to undo that, by specifying the concatenated buffer and the tlv id of the element that should
177	* mark the beginning of a new tlv8 list entry.
178	*
179	* @param data - The concatenated tlv8 list entries (probably output of {@link decode}).
180	* @param entryStartId - The tlv id that marks the beginning of a new tlv8 entry.
181	*/
182	export function decodeList(data: Buffer, entryStartId: number): Record<number, Buffer>[] {	33✔
183	const objectsList: Record<number, Buffer>[] = [];	12✔
184
185	let leftLength = data.length;	12✔
186	let currentIndex = 0;	12✔
187
188	let objects: Record<number, Buffer> \| undefined = undefined;	12✔
189
190	for (; leftLength > 0;) {	12✔
191	const type = data[currentIndex]; // T	36✔
192	const length = data[currentIndex + 1]; // L	36✔
193	const value = data.slice(currentIndex + 2, currentIndex + 2 + length); // V	36✔
194
195	if (type === entryStartId) { // we got the start of a new entry	36✔
196	if (objects !== undefined) { // save the previous entry	21✔
197	objectsList.push(objects);	12✔
198	}
199
200	objects = {};	21✔
201	}
202
203	if (objects === undefined) {	36✔
204	throw new Error("Error parsing tlv list: Encountered uninitialized storage object");	3✔
205	}
206
207	if (objects[type]) { // append to buffer if we have already data for this type	33✔
208	objects[type] = Buffer.concat([objects[type], value]);	3✔
209	} else {
210	objects[type] = value;	30✔
211	}
212
213	currentIndex += 2 + length;	33✔
214	leftLength -= 2 + length;	33✔
215	}
216
217	if (objects !== undefined) {	9✔
218	objectsList.push(objects);	9✔
219	} // push last entry
220
221	return objectsList;	9✔
222	}
223
224	/**
225	* @deprecated This implementation is considered broken. Don't use it.
226	*/
227	export function writeUInt64(value: number): Buffer {	33✔
228	const float64 = new Float64Array(1);	×
229	float64[0] = value;	×
230
231	const buffer = Buffer.alloc(float64.buffer.byteLength);	×
232	const view = new Uint8Array(float64.buffer);	×
233	for (let i = 0; i < buffer.length; i++) {	×
234	buffer[i] = view[i];	×
235	}
236
237	return buffer;	×
238	}
239
240	// noinspection JSUnusedGlobalSymbols
241	/**
242	* @deprecated This implementation is considered broken. Don't use it.
243	*/
244	export function readUInt64(buffer: Buffer): number {	33✔
245	const float64 = new Float64Array(buffer);	×
246	return float64[0];	×
247	}
248
249	export function readUInt64LE(buffer: Buffer, offset = 0): number {	33!
250	const low = buffer.readUInt32LE(offset);	3✔
251	// javascript doesn't allow to shift by 32(?), therefore we multiply here
252	return buffer.readUInt32LE(offset + 4) * 0x100000000 + low;	3✔
253	}
254
255	// noinspection JSUnusedGlobalSymbols
256	/**
257	* @deprecated The method was named wrongfully and actually reads an UInt64 in little endian format.
258	*/
259	export function readUInt64BE(buffer: Buffer, offset = 0): number {	33!
NEW 260	return readUInt64LE(buffer, offset);	×
261	}
262
263	/**
264	* `writeUint32LE`
265	*/
266	export function writeUInt32(value: number): Buffer {	33✔
267	const buffer = Buffer.alloc(4);	3✔
268
269	buffer.writeUInt32LE(value, 0);	3✔
270
271	return buffer;	3✔
272	}
273
274	/**
275	* `readUInt32LE`
276	*/
277	export function readUInt32(buffer: Buffer): number {	33✔
278	return buffer.readUInt32LE(0);	×
279	}
280
281	export function writeFloat32LE(value: number): Buffer {	33✔
282	const buffer = Buffer.alloc(4);	×
283	buffer.writeFloatLE(value, 0);	×
284	return buffer;	×
285	}
286
287	/**
288	* `writeUInt16LE`
289	*/
290	export function writeUInt16(value: number): Buffer {	33✔
291	const buffer = Buffer.alloc(2);	3✔
292
293	buffer.writeUInt16LE(value, 0);	3✔
294
295	return buffer;	3✔
296	}
297
298	/**
299	* `readUInt16LE`
300	*/
301	export function readUInt16(buffer: Buffer): number {	33✔
302	return buffer.readUInt16LE(0);	×
303	}
304
305
306	/**
307	* Reads variable size unsigned integer {@see writeVariableUIntLE}.
308	* @param buffer - The buffer to read from. It must have exactly the size of the given integer.
309	*/
310	export function readVariableUIntLE(buffer: Buffer): number;
311	/**
312	* @deprecated Can't define an offset. The original implementation messed up here!
313	*/
314	export function readVariableUIntLE(buffer: Buffer, offset: number): number;
315	export function readVariableUIntLE(buffer: Buffer, offset = 0): number {	33✔
316	assert(offset === 0, "Can't define a offset different than 0!");	12✔
317
318	switch (buffer.length) {	12!
319	case 1:
320	return buffer.readUInt8(offset);	3✔
321	case 2:
322	return buffer.readUInt16LE(offset);	3✔
323	case 4:
324	return buffer.readUInt32LE(offset);	3✔
325	case 8:
326	return readUInt64LE(buffer, offset);	3✔
327	default:
328	throw new Error("Can't read uint LE with length " + buffer.length);	×
329	}
330	}
331
332	/**
333	* Writes variable size unsigned integer.
334	* Either:
335	* - `UInt8`
336	* - `UInt16LE`
337	* - `UInt32LE`
338	* @param number
339	*/
340	export function writeVariableUIntLE(number: number, ): Buffer;
341	/**
342	* @deprecated Can't define an offset. The original implementation messed up here!
343	*/
344	export function writeVariableUIntLE(number: number, offset: number): Buffer;
345	export function writeVariableUIntLE(number: number, offset = 0): Buffer {	33✔
346	assert(number >= 0, "Can't encode a negative integer as unsigned integer");	18✔
347	assert(offset === 0, "Can't define a offset different than 0!");	15✔
348
349	if (number <= 255) {	12✔
350	const buffer = Buffer.alloc(1);	3✔
351	buffer.writeUInt8(number, offset);	3✔
352	return buffer;	3✔
353	} else if (number <= 65535) {	9✔
354	return writeUInt16(number);	3✔
355	} else if (number <= 4294967295) {	6✔
356	return writeUInt32(number);	3✔
357	} else {
358	const buffer = Buffer.alloc(8);	3✔
359	hapCrypto.writeUInt64LE(number, buffer, offset);	3✔
360	return buffer;	3✔
361	}
362	}

homebridge / HAP-NodeJS / 3232060682

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous