rx-player 3.33.0 → 3.33.1

package/src/utils/__tests__/assert.test.ts

@@ -1,237 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
-import assert, {
-  assertInterface,
-} from "../assert";
-
-describe("utils - assert", () => {
-  it("should throw an error if the assertion is false", () => {
-    let error;
-    try {
-      assert(false);
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message).toBe("invalid assertion");
-    expect(error.name).toBe("AssertionError");
-  });
-
-  it("should be able to take a message argument", () => {
-    const myMessage = "foo bar\n\r";
-    let error;
-    try {
-      assert(false, myMessage);
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message).toBe(myMessage);
-    expect(error.name).toBe("AssertionError");
-  });
-
-  it("should not throw an error if the assertion is true", () => {
-    assert(true);
-  });
-});
-
-describe("utils - assertInterface", () => {
-  it("should throw if undefined or null is given", () => {
-    let error;
-    const nameOfMyObj = "toto titi";
-
-    const objIface = {
-      a: "number",
-      b: "object",
-      d: "function",
-      e: "boolean",
-    };
-    try {
-      assertInterface(undefined, objIface, nameOfMyObj);
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message).toBe(`${nameOfMyObj} should be an object`);
-    expect(error.name).toBe("AssertionError");
-
-    error = null;
-
-    try {
-      assertInterface(null, objIface, nameOfMyObj);
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message).toBe(`${nameOfMyObj} should be an object`);
-    expect(error.name).toBe("AssertionError");
-  });
-
-  it("should throw if the concerned interface is not respected", () => {
-    let error;
-    const nameOfMyObj = "toto titi";
-    const myObj = {
-      a: 45,
-      b: {
-        c: "toto",
-      },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
-      e: true,
-    };
-
-    const objIface = {
-      a: "number",
-      b: "object",
-      d: "function",
-      e: "boolean",
-      f: "function", // one more key
-    };
-
-    try {
-      assertInterface(myObj, objIface, nameOfMyObj);
-    } catch (e) {
-      error = e;
-    }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
-
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message)
-      .toBe(`${nameOfMyObj} should have property f as a function`);
-    expect(error.name).toBe("AssertionError");
-  });
-
-  it("should name the interface 'object' if no name is specified", () => {
-    let error;
-    const myObj = {
-      a: 45,
-      b: {
-        c: "toto",
-      },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
-      e: true,
-    };
-
-    const objIface = {
-      a: "number",
-      b: "object",
-      d: "function",
-      e: "boolean",
-      f: "function", // one more key
-    };
-
-    try {
-      assertInterface(myObj, objIface);
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message)
-      .toBe("object should have property f as a function");
-    expect(error.name).toBe("AssertionError");
-  });
-
-  it("should not throw if the concerned interface is respected", () => {
-    const nameOfMyObj = "toto titi";
-    const myObj = {
-      a: 45,
-      b: {
-        c: "toto",
-      },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
-      e: true,
-    };
-
-    const objIface = {
-      a: "number",
-      b: "object",
-      d: "function",
-      e: "boolean",
-    };
-
-    assertInterface(myObj, objIface, nameOfMyObj);
-  });
-
-  /* eslint-disable max-len */
-  it("should not consider inherited properties as part of the interface", () => {
-  /* eslint-enable max-len */
-
-    const nameOfMyObj = "toto titi";
-    const myObj = {
-      a: 45,
-      b: {
-        c: "toto",
-      },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
-      e: true,
-    };
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (Object.prototype as any).f = "number";
-
-    const objIface = {
-      a: "number",
-      b: "object",
-      d: "function",
-      e: "boolean",
-    };
-
-    assertInterface(myObj, objIface, nameOfMyObj);
-  });
-});

package/src/utils/__tests__/assert_unreachable.test.ts

@@ -1,40 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
-import assertUnreachable from "../assert_unreachable";
-
-describe("utils - assert", () => {
-  it("should throw an error if the function is called", () => {
-    let error;
-    try {
-      assertUnreachable(4 as never);
-    } catch (e : unknown) {
-      error = e;
-    }
-
-    expect(error).toBeInstanceOf(Error);
-
-    // Impossible check to shut-up TypeScript
-    if (!(error instanceof Error)) {
-      throw new Error("Impossible: already checked it was an Error instance");
-    }
-    expect(error.message).toBe("Unreachable path taken");
-    expect(error.name).toBe("AssertionError");
-  });
-});

package/src/utils/__tests__/base64.test.ts

@@ -1,147 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-
-/** Every chars defined in base64. */
-const CHARS = [
-  "A",          "R",          "i",          "z",
-  "B",          "S",          "j",          "0",
-  "C",          "T",          "k",          "1",
-  "D",          "U",          "l",          "2",
-  "E",          "V",          "m",          "3",
-  "F",          "W",          "n",          "4",
-  "G",          "X",          "o",          "5",
-  "H",          "Y",          "p",          "6",
-  "I",          "Z",          "q",          "7",
-  "J",          "a",          "r",          "8",
-  "K",          "b",          "s",          "9",
-  "L",          "c",          "t",          "+",
-  "M",          "d",          "u",          "/",
-  "N",          "e",          "v",
-  "O",          "f",          "w",
-  "P",          "g",          "x",
-  "Q",          "h",          "y",
-];
-
-describe("base64ToBytes", () => {
-  const logWarn = jest.fn();
-  beforeEach(() => {
-    jest.resetModules();
-    logWarn.mockReset();
-    jest.mock("../../log", () =>  ({ default: { warn: logWarn },
-                                     __esModule: true as const }));
-  });
-
-  it("should return an empty Uint8Array for an empty string", () => {
-    const base64ToBytes = jest.requireActual("../base64").base64ToBytes;
-    expect(base64ToBytes("")).toEqual(new Uint8Array([]));
-    expect(logWarn).not.toHaveBeenCalled();
-  });
-
-  it("should convert a base64 to an Uint8Array", () => {
-    const base64ToBytes = jest.requireActual("../base64").base64ToBytes;
-    expect(base64ToBytes("woDCge+/vg=="))
-      .toEqual(new Uint8Array([194, 128, 194, 129, 239, 191, 190]));
-    expect(base64ToBytes("dG90b/CfjIM="))
-      .toEqual(new Uint8Array([116, 111, 116, 111, 240, 159, 140, 131]));
-    expect(base64ToBytes("JGV4cGVjdChiYXNlNjRUb1VpbnQ4QXJyYXkoIiIp"))
-      .toEqual(new Uint8Array([ 36, 101, 120, 112, 101, 99, 116, 40, 98, 97,
-                                115, 101, 54, 52, 84, 111, 85, 105, 110, 116,
-                                56, 65, 114, 114, 97, 121, 40, 34, 34, 41 ]));
-    expect(base64ToBytes(window.btoa("toto")))
-      .toEqual(new Uint8Array([ 116, 111, 116, 111 ]));
-    expect(logWarn).not.toHaveBeenCalled();
-
-    const bytesToBase64 = jest.requireActual("../base64").bytesToBase64;
-
-    for (let i = 0; i < CHARS.length; i++) {
-      const char1 = CHARS[i];
-      for (let j = 0; j < CHARS.length; j++) {
-        const char2 = CHARS[j];
-        // for (let k = 0; k < CHARS.length; k++) {
-        //   const char3 = CHARS[j];
-        //   for (let l = 0; l < CHARS.length; l++) {
-        //     const char4 = CHARS[j];
-        const combination = char1 + char2 + char2 + char1;
-        expect(bytesToBase64(base64ToBytes(combination)))
-          .toEqual(combination);
-          // }
-        // }
-      }
-    }
-  });
-
-  it("should convert a non-padded base64 to an Uint8Array", () => {
-    const base64ToBytes = jest.requireActual("../base64").base64ToBytes;
-    expect(base64ToBytes("woDCge+/vg"))
-      .toEqual(new Uint8Array([194, 128, 194, 129, 239, 191, 190]));
-    expect(logWarn).toHaveBeenCalledTimes(1);
-    expect(logWarn)
-      .toHaveBeenNthCalledWith(1, "base64ToBytes: base64 given miss padding");
-    expect(base64ToBytes("dG90b/CfjIM"))
-      .toEqual(new Uint8Array([116, 111, 116, 111, 240, 159, 140, 131]));
-    expect(logWarn).toHaveBeenCalledTimes(2);
-    expect(logWarn)
-      .toHaveBeenNthCalledWith(1, "base64ToBytes: base64 given miss padding");
-  });
-
-  it("should fail on invalid data", () => {
-    const base64ToBytes = jest.requireActual("../base64").base64ToBytes;
-    expect(() => base64ToBytes("woD=Cge+/vg="))
-      .toThrowError("Unable to parse base64 string.");
-    expect(() => base64ToBytes("woDCg{+/vg=="))
-      .toThrowError("Unable to parse base64 string.");
-    expect(() => base64ToBytes("dG90b/Cfj==="))
-      .toThrowError("Unable to parse base64 string.");
-  });
-});
-
-describe("bytesToBase64", () => {
-  const logWarn = jest.fn();
-  beforeEach(() => {
-    jest.resetModules();
-    logWarn.mockReset();
-    jest.mock("../../log", () =>  ({ default: { warn: logWarn },
-                                     __esModule: true as const }));
-  });
-
-  it("should return an empty string for an empty Uint8Array", () => {
-    const bytesToBase64 = jest.requireActual("../base64").bytesToBase64;
-    expect(bytesToBase64(new Uint8Array([]))).toEqual("");
-    expect(logWarn).not.toHaveBeenCalled();
-  });
-
-  it("should convert a base64 to an Uint8Array", () => {
-    const bytesToBase64 = jest.requireActual("../base64").bytesToBase64;
-    expect(bytesToBase64(new Uint8Array([194, 128, 194, 129, 239, 191, 190])))
-      .toEqual("woDCge+/vg==");
-    expect(bytesToBase64(new Uint8Array([116, 111, 116, 111, 240, 159, 140, 131])))
-      .toEqual("dG90b/CfjIM=");
-    expect(bytesToBase64(new Uint8Array([ 36, 101, 120, 112, 101, 99, 116, 40, 98, 97,
-                                          115, 101, 54, 52, 84, 111, 85, 105, 110, 116,
-                                          56, 65, 114, 114, 97, 121, 40, 34, 34, 41 ])))
-      .toEqual("JGV4cGVjdChiYXNlNjRUb1VpbnQ4QXJyYXkoIiIp");
-    expect(bytesToBase64(new Uint8Array([ 116, 111, 116, 111 ])))
-      .toEqual(window.btoa("toto"));
-    expect(logWarn).not.toHaveBeenCalled();
-  });
-});

package/src/utils/__tests__/byte_parsing.test.ts

@@ -1,267 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import * as byteUtils from "../byte_parsing";
-
-describe("utils - byte parsing", () => {
-  describe("concat", () => {
-    it("should return an empty Uint8Array if no arguments are provided", () => {
-      const res = byteUtils.concat();
-      expect(res).toBeInstanceOf(Uint8Array);
-      expect(res).toHaveLength(0);
-    });
-
-    it("should concatenate multiple Uint8Array in a single Uint8Array", () => {
-      const arr1 = new Uint8Array([54, 255]);
-      const arr2 = new Uint8Array([258, 54]);
-      const arr3 = new Uint8Array([]);
-      const arr4 = new Uint8Array([34, 87]);
-      const expected = new Uint8Array([54, 255, 258, 54, 34, 87]);
-      const res = byteUtils.concat(arr1, arr2, arr3, arr4);
-      expect(res).toHaveLength(arr1.length + arr2.length + arr3.length + arr4.length);
-      res.forEach((x, i) => expect(x).toBe(expected[i]));
-    });
-
-    it("should consider number arguments as 0-filled offests", () => {
-      const arr1 = new Uint8Array([54, 255]);
-      const arr2 = new Uint8Array([258, 54]);
-      const arr3 = new Uint8Array([34, 87]);
-      const expected = new Uint8Array(
-        [54, 255, 0, 0, 258, 54, 34, 87, 0].map(e => e & 0xFF)
-      );
-      const res = byteUtils.concat(0, arr1, 2, arr2, arr3, 1);
-      expect(res).toHaveLength(
-        arr1.length + arr2.length + arr3.length + 0 + 2 + 1
-      );
-      res.forEach((x, i) => expect(x).toBe(expected[i]));
-    });
-
-    it("should return only 0-filled arrays if only numbers are provided", () => {
-      const res = byteUtils.concat(0);
-      expect(res).toHaveLength(0);
-
-      const res2 = byteUtils.concat(10, 2);
-      expect(res2).toHaveLength(10 + 2);
-      res2.forEach(x => expect(x).toBe(0));
-    });
-  });
-
-  describe("be2toi", () => {
-    it("should return 0 for an empty TypedArray", () => {
-      expect(byteUtils.be2toi(new Uint8Array(0), 0)).toBe(0);
-    });
-
-    it("should return 0 for an out-of-bound offset", () => {
-      const arr = new Uint8Array([255, 255, 1, 8]);
-      expect(byteUtils.be2toi(arr, -45)).toBe(0);
-      expect(byteUtils.be2toi(arr, 45)).toBe(0);
-    });
-
-    /* eslint-disable max-len */
-    it("should return the number value for the 2 first elements of an Uint8Array from the offset", () => {
-    /* eslint-enable max-len */
-      // as the test would be equivalent to re-implement the function, I
-      // directly take the expected result (number to hex and hex to
-      // number) and compare
-      const arr = new Uint8Array([255, 255, 1, 8]);
-      const expected = [65535, 65281, 264, 2048];
-      expect(byteUtils.be2toi(arr, 0)).toBe(expected[0]);
-      expect(byteUtils.be2toi(arr, 1)).toBe(expected[1]);
-      expect(byteUtils.be2toi(arr, 2)).toBe(expected[2]);
-      expect(byteUtils.be2toi(arr, 3)).toBe(expected[3]);
-    });
-  });
-
-  describe("be3toi", () => {
-    /* eslint-disable max-len */
-    it("should return the number value for the 2 first elements of an Uint8Array from the offset", () => {
-    /* eslint-enable max-len */
-      // as the test would be equivalent to re-implement the function, I
-      // directly take the expected result (number to hex and hex to
-      // number) and compare
-      const arr = new Uint8Array([255, 255, 255, 1, 8, 17]);
-      const expected = [16777215, 16776961, 16711944, 67601];
-      expect(byteUtils.be3toi(arr, 0)).toBe(expected[0]);
-      expect(byteUtils.be3toi(arr, 1)).toBe(expected[1]);
-      expect(byteUtils.be3toi(arr, 2)).toBe(expected[2]);
-      expect(byteUtils.be3toi(arr, 3)).toBe(expected[3]);
-    });
-  });
-
-  describe("be4toi", () => {
-    /* eslint-disable max-len */
-    it("should return the number value for the 4 first elements of an Uint8Array from the offset", () => {
-    /* eslint-enable max-len */
-      // as the test would be equivalent to re-implement the function, I
-      // directly take the expected result (number to hex and hex to
-      // number) and compare
-      const arr = new Uint8Array([ 0, 0, 0, 1, 255, 3, 2 ]);
-      const expected = [ 1, 511, 130819, 33489666 ];
-      expect(byteUtils.be4toi(arr, 0)).toBe(expected[0]);
-      expect(byteUtils.be4toi(arr, 1)).toBe(expected[1]);
-      expect(byteUtils.be4toi(arr, 2)).toBe(expected[2]);
-      expect(byteUtils.be4toi(arr, 3)).toBe(expected[3]);
-    });
-  });
-
-  describe("be8toi", () => {
-    /* eslint-disable max-len */
-    it("should return the number value for the 8 first elements of an Uint8Array from the offset", () => {
-    /* eslint-enable max-len */
-      // as the test would be equivalent to re-implement the function, I
-      // directly take the expected result (number to hex and hex to
-      // number) and compare
-      const arr = new Uint8Array([
-        0, 0, 0, 0, 0, 0, 0, 1,
-        0, 0, 255, 0, 255, 0, 255, 0 ]); // I can't set the top-most byte or I
-                                         // go over MAX_SAFE_INTEGER
-      const expected = [ 1, 280379743338240 ];
-      expect(byteUtils.be8toi(arr, 0)).toBe(expected[0]);
-      expect(byteUtils.be8toi(arr, 8)).toBe(expected[1]);
-    });
-  });
-
-  describe("le2toi", () => {
-    it("should return 0 for an empty TypedArray", () => {
-      expect(byteUtils.le2toi(new Uint8Array(0), 0)).toBe(0);
-    });
-
-    it("should return 0 for an out-of-bound offset", () => {
-      const arr = new Uint8Array([255, 255, 1, 8]);
-      expect(byteUtils.le2toi(arr, -45)).toBe(0);
-      expect(byteUtils.le2toi(arr, 45)).toBe(0);
-    });
-
-    it(
-      /* eslint-disable max-len */
-      "should return the number value for the 2 first elements of an Uint8Array from the offset, little-endian style",
-      /* eslint-enable max-len */
-      () => {
-        // as the test would be equivalent to re-implement the function, I
-        // directly take the expected result (number to hex and hex to
-        // number) and compare
-        const arr = new Uint8Array([8, 1, 255, 255]);
-        const expected = [264, 65281, 65535, 255];
-        expect(byteUtils.le2toi(arr, 0)).toBe(expected[0]);
-        expect(byteUtils.le2toi(arr, 1)).toBe(expected[1]);
-        expect(byteUtils.le2toi(arr, 2)).toBe(expected[2]);
-        expect(byteUtils.le2toi(arr, 3)).toBe(expected[3]);
-      });
-  });
-
-  describe("le4toi", () => {
-    it(
-      /* eslint-disable max-len */
-      "should return the number value for the 4 first elements of an Uint8Array from the offset, little-endian style",
-      /* eslint-enable max-len */
-      () => {
-        // as the test would be equivalent to re-implement the function, I
-        // directly take the expected result (number to hex and hex to
-        // number) and compare
-        const arr = new Uint8Array([2, 3, 255, 1, 0, 0, 0]);
-        const expected = [ 33489666, 130819, 511, 1 ];
-        expect(byteUtils.le4toi(arr, 0)).toBe(expected[0]);
-        expect(byteUtils.le4toi(arr, 1)).toBe(expected[1]);
-        expect(byteUtils.le4toi(arr, 2)).toBe(expected[2]);
-        expect(byteUtils.le4toi(arr, 3)).toBe(expected[3]);
-      });
-  });
-
-  describe("le8toi", () => {
-    it(
-      /* eslint-disable max-len */
-      "should return the number value for the 8 first elements of an Uint8Array from the offset, little-endian style",
-      /* eslint-enable max-len */
-      () => {
-        // as the test would be equivalent to re-implement the function, I
-        // directly take the expected result (number to hex and hex to
-        // number) and compare
-        const arr = new Uint8Array([
-          1, 0, 0, 0, 0, 0, 0, 0,
-          0, 255, 0, 255, 0, 255, 0, 0 ]); // I can't set the top-most byte or I
-                                           // go over MAX_SAFE_INTEGER
-        const expected = [ 1, 280379743338240 ];
-        expect(byteUtils.le8toi(arr, 0)).toBe(expected[0]);
-        expect(byteUtils.le8toi(arr, 8)).toBe(expected[1]);
-      });
-  });
-
-  describe("itobe2", () => {
-    /* eslint-disable max-len */
-    it("should convert the number given into two elements in a Uint8Array", () => {
-    /* eslint-enable max-len */
-      expect(byteUtils.itobe2(65535))
-        .toEqual(new Uint8Array([255, 255]));
-      expect(byteUtils.itobe2(65281))
-        .toEqual(new Uint8Array([255, 1]));
-      expect(byteUtils.itobe2(264))
-        .toEqual(new Uint8Array([1, 8]));
-    });
-  });
-
-  describe("itobe4", () => {
-    /* eslint-disable max-len */
-    it("should convert the number given into four elements in a Uint8Array", () => {
-    /* eslint-enable max-len */
-      expect(byteUtils.itobe4(1))
-        .toEqual(new Uint8Array([0, 0, 0, 1]));
-      expect(byteUtils.itobe4(511))
-        .toEqual(new Uint8Array([0, 0, 1, 255]));
-      expect(byteUtils.itobe4(130819))
-        .toEqual(new Uint8Array([0, 1, 255, 3]));
-      expect(byteUtils.itobe4(33489666))
-        .toEqual(new Uint8Array([1, 255, 3, 2]));
-    });
-  });
-
-  describe("itobe8", () => {
-    /* eslint-disable max-len */
-    it("should return the number value for the 8 first elements of an Uint8Array from the offset", () => {
-    /* eslint-enable max-len */
-      expect(byteUtils.itobe8(1))
-        .toEqual(new Uint8Array([0, 0, 0, 0, 0, 0, 0, 1]));
-      expect(byteUtils.itobe8(1237106686452549))
-        .toEqual(new Uint8Array([0x00, 0x04, 0x65, 0x24, 0x58, 0x98, 0x63, 0x45]));
-    });
-  });
-
-  describe("itole2", () => {
-    /* eslint-disable max-len */
-    it("should return a little-endian style Uint8Array of length 2 translated from the number given", () => {
-    /* eslint-enable max-len */
-      const values = [264, 65281, 65535, 255];
-      expect(byteUtils.itole2(values[0])).toEqual(new Uint8Array([8, 1]));
-      expect(byteUtils.itole2(values[1])).toEqual(new Uint8Array([1, 255]));
-      expect(byteUtils.itole2(values[2])).toEqual(new Uint8Array([255, 255]));
-    });
-  });
-
-  describe("itole4", () => {
-    /* eslint-disable max-len */
-    it("should return a little-endian style Uint8Array of length 4 translated from the number given", () => {
-    /* eslint-enable max-len */
-      const values = [ 33489666, 130819, 511, 1 ];
-      expect(byteUtils.itole4(values[0]))
-        .toEqual(new Uint8Array([2, 3, 255, 1]));
-      expect(byteUtils.itole4(values[1]))
-        .toEqual(new Uint8Array([3, 255, 1, 0]));
-      expect(byteUtils.itole4(values[2]))
-        .toEqual(new Uint8Array([255, 1, 0, 0]));
-      expect(byteUtils.itole4(values[3]))
-        .toEqual(new Uint8Array([1, 0, 0, 0]));
-    });
-  });
-});