@odoo/o-spreadsheet 14.0.1 → 15.0.0

package/tests/functions/module_math_test.ts

@@ -1,2482 +0,0 @@
-import { toNumber } from "../../src/functions/helpers";
-import { evaluateCell, evaluateGrid } from "../helpers";
-
-describe("math", () => {
-  //----------------------------------------------------------------------------
-  // ACOS
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", 0],
-    ["-1", Math.PI],
-    ["0", Math.PI / 2],
-    ["0.5", Math.PI / 3],
-  ])("ACOS(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["2"], ["-1.5"]])("ACOS(%s) - ERROR: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-  });
-
-  test("ACOS: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=ACOS()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ACOS(TRUE)" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=ACOS(FALSE)" })).toBeCloseTo(Math.PI / 2, 9);
-
-    expect(evaluateCell("A1", { A1: '=ACOS("")' })).toBeCloseTo(Math.PI / 2, 9);
-    expect(evaluateCell("A1", { A1: '=ACOS(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ACOS("0")' })).toBeCloseTo(Math.PI / 2, 9);
-
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: "" })).toBeCloseTo(Math.PI / 2, 9);
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: "0" })).toBeCloseTo(Math.PI / 2, 9);
-
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: '"0"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: '=""' })).toBeCloseTo(Math.PI / 2, 9);
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ACOS(A2)", A2: '="0"' })).toBeCloseTo(Math.PI / 2, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // ACOSH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1.54308063481524", 1],
-    ["1", 0],
-    ["1.25", Math.log(2)],
-    ["2.125", Math.log(4)],
-  ])("ACOSH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ACOSH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["-2"], ["0.5"]])("ACOSH(%s) - ERROR: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=ACOSH(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-  });
-
-  //----------------------------------------------------------------------------
-  // ACOT
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", Math.PI / 2],
-    ["1", Math.PI / 4],
-    ["-1", -Math.PI / 4],
-    ["2", 0.463647609],
-    ["-4", -0.244978663],
-  ])("ACOT(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ACOT(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // ACOTH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1.25", Math.log(3)],
-    ["1.1", 1.522261219],
-    ["2", 0.549306144],
-    ["-3", -0.34657359],
-    ["-4", -0.255412812],
-  ])("ACOTH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ACOTH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0"], ["1"], ["-1"], ["0.5"]])(
-    "ACOTH(%s) - ERROR: take 1 parameter(s), return an error",
-    (a) => {
-      expect(evaluateCell("A1", { A1: "=ACOTH(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    }
-  );
-
-  //----------------------------------------------------------------------------
-  // ASIN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", Math.PI / 2],
-    ["-1", -Math.PI / 2],
-    ["0", 0],
-    ["0.5", Math.PI / 6],
-  ])("ASIN(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ASIN(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["2"], ["-1.5"]])("ASIN(%s) - ERROR: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=ASIN(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-  });
-
-  //----------------------------------------------------------------------------
-  // ASINH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1.175201194", 1],
-    ["-3.626860408", -2],
-    ["0", 0],
-    ["0.75", Math.log(2)],
-    ["-1.875", -Math.log(4)],
-  ])("ASINH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ASINH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // ATAN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 0],
-    ["1", Math.PI / 4],
-    ["1.557407725", 1],
-    ["-2", -1.107148718],
-    ["-4", -1.325817664],
-  ])("ATAN(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ATAN(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // ATAN2
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["42", "0", 0],
-    ["0", "42", Math.PI / 2],
-    ["2", "2", Math.PI / 4],
-    ["-2", "3", 2.15879893],
-    ["4", "-7", -1.051650213],
-  ])("ATAN2(%s, %s) - %s: take 1 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=ATAN2(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0", "0"]])("ATAN2(%s, %s) - ERROR: take 1 parameter(s), return an error", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=ATAN2(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-  });
-
-  //----------------------------------------------------------------------------
-  // ATANH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0.8", Math.log(3)],
-    ["0.6", Math.log(2)],
-    ["0", 0],
-    [" 0.761594156", 1],
-    ["-0.9", -1.47221949],
-  ])("ATANH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ATANH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["1.1"], ["-1"], ["42"]])(
-    "ATANH(%s) - ERROR: take 1 parameter(s), return an error",
-    (a) => {
-      expect(evaluateCell("A1", { A1: "=ATANH(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    }
-  );
-
-  //----------------------------------------------------------------------------
-  // CEILING / CEILING.MATH / CEILING.PRECISE / ISO.CEILING
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 0],
-    ["6", 6],
-    ["-6", -6],
-    ["6.7", 7],
-    ["7.89", 8],
-    ["-6.7", -6],
-    ["-7.89", -7],
-  ])("CEILING FUNCTIONS(%s) - %s: take 1 parameters, return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=CEILING(A2)", A2: a })).toBe(expected);
-    expect(evaluateCell("A1", { A1: "=CEILING.MATH(A2)", A2: a })).toBe(expected);
-    expect(evaluateCell("A1", { A1: "=CEILING.PRECISE(A2)", A2: a })).toBe(expected);
-    expect(evaluateCell("A1", { A1: "=ISO.CEILING(A2)", A2: a })).toBe(expected);
-  });
-
-  test.each([
-    ["0", "0", 0],
-    ["0", "0.1", 0],
-    ["0", "-4", 0],
-    ["6", "0", 0],
-    ["6.7", "0", 0],
-    ["-6", "0", 0],
-    ["6", "0.1", 6],
-    ["-6", "0.1", -6],
-    ["6", "0.7", 6.3],
-    ["-6", "0.7", -5.6],
-    ["6.7", "0.2", 6.8],
-    ["-6.7", "0.2", -6.6],
-  ])("CEILING FUNCTIONS(%s, %s) - %s: take 2 parameters, return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=CEILING(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected, 9);
-    expect(evaluateCell("A1", { A1: "=CEILING.MATH(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-      expected,
-      9
-    );
-    expect(evaluateCell("A1", { A1: "=CEILING.PRECISE(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-      expected,
-      9
-    );
-    expect(evaluateCell("A1", { A1: "=ISO.CEILING(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-      expected,
-      9
-    );
-  });
-
-  test.each([
-    ["0", "0.2", 0],
-    ["0", "-0.2", 0],
-    ["7.89", "0.2", 8],
-    ["7.89", "-0.2", 8],
-    ["-7.89", "0.2", -7.8],
-    ["-7.89", "-0.2", -7.8],
-  ])(
-    "CEILING (MATH/PRECISE/ISO) FUNCTIONS(%s, %s) - %s: no effect with negative factor",
-    (a, b, expected) => {
-      expect(evaluateCell("A1", { A1: "=CEILING.MATH(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-        expected,
-        9
-      );
-      expect(evaluateCell("A1", { A1: "=CEILING.PRECISE(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-        expected,
-        9
-      );
-      expect(evaluateCell("A1", { A1: "=ISO.CEILING(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-        expected,
-        9
-      );
-    }
-  );
-
-  test.each([
-    ["6", "-0.2"],
-    ["7.89", "-0.2"],
-  ])("CEILING(%s, %s) - error: if value positive, factor can't be negative", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=CEILING(A2, A3)", A2: a, A3: b })).toBe("#ERROR");
-  });
-
-  test.each([
-    // Concerning CEILING function
-    // if "a" is negative and "b" is negative, rounds a number down (and not up)
-    // the nearest integer multiple of b
-    ["-7.89", "0.2", -7.8],
-    ["-7.89", "-0.2", -8],
-  ])("CEILING(%s, %s) - %s: if factor negative, rounds number down", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=CEILING(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([
-    // Concerning CEILING.MATH function
-    // if "a" is negative and "c" different 0, rounds a number down (and not up)
-    // the nearest integer multiple of b
-    ["7.89", "0.2", "0", 8],
-    ["7.89", "0.2", "1", 8],
-    ["-7.89", "0.2", "0", -7.8],
-    ["-7.89", "0.2", "1", -8],
-    ["-7.89", "0.2", "2.2", -8],
-    ["-7.89", "0.2", "-2.2", -8],
-    ["-7.89", "-0.2", "0", -7.8],
-    ["-7.89", "-0.2", "1", -8],
-    ["-7.89", "-0.2", "2.2", -8],
-    ["-7.89", "-0.2", "-2.2", -8],
-  ])("CEILING.MATH(%s, %s, %s) - %s: take 3 parameters, return a number", (a, b, c, expected) => {
-    expect(
-      evaluateCell("A1", { A1: "=CEILING.MATH(A2, A3, A4)", A2: a, A3: b, A4: c })
-    ).toBeCloseTo(expected, 9);
-  });
-
-  function evaluateCeilingFunction(functionName: string): void {
-    expect(evaluateCell("A1", { A1: "=" + functionName + "()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=" + functionName + "( , )" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, 0.2)" })).toBeCloseTo(-7.8, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "( , 0.2)" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, )" })).toBeCloseTo(0, 9); // @compatibility: on google sheets, return -7
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, TRUE)" })).toBeCloseTo(-7, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, FALSE)" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(TRUE, 10)" })).toBeCloseTo(10, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(FALSE, 10)" })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=" + functionName + '("" , "")' })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + '(" " , " ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=" + functionName + '("-7.89", "0.2")' })).toBeCloseTo(
-      -7.8,
-      9
-    );
-
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "", A3: "" })).toBeCloseTo(
-      0,
-      9
-    );
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: " ", A3: " " })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "0.2" })
-    ).toBeCloseTo(-7.8, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "", A3: "0.2" })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "" })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "TRUE" })
-    ).toBeCloseTo(-7, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "FALSE" })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "TRUE", A3: "10" })
-    ).toBeCloseTo(10, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "FALSE", A3: "10" })
-    ).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '""', A3: '""' })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '" "', A3: '" "' })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '"-7.89"', A3: '"0.2"' })
-    ).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '=""', A3: '=""' })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '=" "', A3: '=" "' })
-    ).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '="-7.89"', A3: '="0.2"' })
-    ).toBeCloseTo(-7.8, 9);
-  }
-
-  test.each([["CEILING"], ["CEILING.MATH"], ["CEILING.PRECISE"], ["ISO.CEILING"]])(
-    "%s: special value testing",
-    (functionName) => {
-      evaluateCeilingFunction(functionName);
-    }
-  );
-
-  //----------------------------------------------------------------------------
-  // COS
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 1],
-    ["=PI()", -1],
-    ["=PI()*2", 1],
-    ["=PI()/2", 0],
-    ["=PI()/3", 0.5],
-    ["=-PI()/2", 0],
-  ])("COS(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test("COS: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=COS()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=COS(TRUE)" })).toBeCloseTo(0.54030230586814, 9);
-    expect(evaluateCell("A1", { A1: "=COS(FALSE)" })).toBeCloseTo(1, 9);
-
-    expect(evaluateCell("A1", { A1: '=COS("")' })).toBeCloseTo(1, 9);
-    expect(evaluateCell("A1", { A1: '=COS(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=COS("0")' })).toBeCloseTo(1, 9);
-
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: "" })).toBeCloseTo(1, 9);
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: "0" })).toBeCloseTo(1, 9);
-
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: '"0"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: '=""' })).toBeCloseTo(1, 9);
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=COS(A2)", A2: '="0"' })).toBeCloseTo(1, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // COSH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 1],
-    ["1", 1.543080635],
-    ["-1", 1.543080635],
-    ["=LN(2)", 1.25],
-    ["=LN(4)", 2.125],
-  ])("COSH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=COSH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // COT
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["=PI()/2", 0],
-    ["=PI()/4", 1],
-    ["=-PI()*5/4", -1],
-    ["1", 0.642092616],
-    ["2", -0.457657554],
-  ])("COT(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=COT(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0"]])("COT(%s) - %s: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=COT(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!!
-  });
-
-  //----------------------------------------------------------------------------
-  // COTH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["=LN(3)", 1.25],
-    ["1", 1.313035285],
-    ["2", 1.037314721],
-    ["-3", -1.004969823],
-    ["-4", -1.00067115],
-  ])("COTH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=COTH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0"]])("COTH(%s) - %s: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=COTH(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!!
-  });
-
-  //----------------------------------------------------------------------------
-  // COUNTBLANK
-  //----------------------------------------------------------------------------
-
-  test("COUNTBLANK: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(,)" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(0)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(42)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(TRUE)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(FALSE)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=COUNTBLANK("")' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=COUNTBLANK(" ")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=COUNTBLANK("hello there")' })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: "" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: " " })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: "0" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: "42" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: "TRUE" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: "FALSE" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: '""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: '" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: '"42"' })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: '=""' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=COUNTBLANK(A2)", A2: '="42"' })).toBe(0);
-  });
-
-  // prettier-ignore
-  test("COUNTBLANK: count blank on ranges ", () => {
-    const grid = {
-
-      B1: "=COUNTBLANK(D1:I2)",
-      C1: "=COUNTBLANK(D1:I1)",
-      C2: "=COUNTBLANK(D2:I2)",
-
-      D1: "0", E1: "1", F1: "2",  G1: "",      H1: '""',   I1: "",
-      D2: "",  E2: "",  F2: '""', G2: "FALSE", H2: "TRUE", I2: "42",
-
-      A2: "=COUNTBLANK(A4:B9)",
-      A3: "=COUNTBLANK(A4:A9)", B3: "=COUNTBLANK(B4:B9)",
-
-      A4: "0",  B4: "",
-      A5: "1",  B5: "",
-      A6: "2",  B6: '""',
-      A7: "",   B7: "FALSE",
-      A8: '""', B8: "TRUE",
-      A9: "",   B9: "42",
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.B1).toBe(4);
-    expect(gridResult.C1).toBe(2);
-    expect(gridResult.C2).toBe(2);
-    expect(gridResult.A2).toBe(4);
-    expect(gridResult.A3).toBe(2);
-    expect(gridResult.B3).toBe(2);
-  });
-
-  //----------------------------------------------------------------------------
-  // COUNTIF
-  //----------------------------------------------------------------------------
-
-  // prettier-ignore
-  test("COUNTIF: operator tests on type number and type string", () => {
-    
-    const grid = {
-      A1 : "1" , B1 : '="1"',
-      A2 : "10", B2 : '="10"',
-      A3 : "2" , B3 : '="2"',
-      A4 : "20", B4 : '="20"',
-      A5 : "3" , B5 : '="3"',
-      A6 : "30", B6 : '="30"',
-      A7 : "4" , B7 : '="4"',
-      A8 : "40", B8 : '="40"',
-
-      A10: "=COUNTIF(A1:A8, 20)"      , B10: "=COUNTIF(B1:B8, 20)",
-      A11: '=COUNTIF(A1:A8, "20")'    , B11: '=COUNTIF(B1:B8, "20")',
-      A12: '=COUNTIF(A1:A8, "=20")'   , B12: '=COUNTIF(B1:B8, "=20")',
-
-      A14: '=COUNTIF(A1:A8, "2*")'    , B14: '=COUNTIF(B1:B8, "2*")',
-
-      A16: '=COUNTIF(A1:A8, "<20")'   , B16: '=COUNTIF(B1:B8, "<20")',
-      A17: '=COUNTIF(A1:A8, ">20")'   , B17: '=COUNTIF(B1:B8, ">20")',
-
-      A19: '=COUNTIF(A1:A8, "< 20 ")' , B19: '=COUNTIF(B1:B8, "< 20 ")',
-      A20: '=COUNTIF(A1:A8, "> 20 ")' , B20: '=COUNTIF(B1:B8, "> 20 ")',
-
-      A22: '=COUNTIF(A1:A8, "< 20% ")', B22: '=COUNTIF(B1:B8, "< 20% ")',
-      A23: '=COUNTIF(A1:A8, "> 20% ")', B23: '=COUNTIF(B1:B8, "> 20% ")',
-
-      A25: '=COUNTIF(A1:A8, "<a")'    , B25: '=COUNTIF(B1:B8, "<a")',
-      A26: '=COUNTIF(A1:A8, ">a")'    , B26: '=COUNTIF(B1:B8, ">a")',
-
-      A28: '=COUNTIF(A1:A8, "<20A")'  , B28: '=COUNTIF(B1:B8, "<20A")',
-      A29: '=COUNTIF(A1:A8, ">20A")'  , B29: '=COUNTIF(B1:B8, ">20A")',
-
-      A31: '=COUNTIF(A1:A8, "<2*")'   , B31: '=COUNTIF(B1:B8, "<2*")',
-      A32: '=COUNTIF(A1:A8, ">2*")'   , B32: '=COUNTIF(B1:B8, ">2*")',
-
-      A34: '=COUNTIF(A1:A8, "<2?")'   , B34: '=COUNTIF(B1:B8, "<2?")',
-      A35: '=COUNTIF(A1:A8, ">2?")'   , B35: '=COUNTIF(B1:B8, ">2?")',
-
-      A37: '=COUNTIF(A1:A8, "<>20")'  , B37: '=COUNTIF(B1:B8, "<>20")',
-    };
-
-    const gridResult = evaluateGrid(grid);
-
-    expect(gridResult.A10).toBe(1);  expect(gridResult.B10).toBe(1);
-    expect(gridResult.A11).toBe(1);  expect(gridResult.B11).toBe(1);
-    expect(gridResult.A12).toBe(1);  expect(gridResult.B12).toBe(1);
-
-    expect(gridResult.A14).toBe(0);  expect(gridResult.B14).toBe(2);
-
-    expect(gridResult.A16).toBe(5);  expect(gridResult.B16).toBe(0);
-    expect(gridResult.A17).toBe(2);  expect(gridResult.B17).toBe(0);
-
-    expect(gridResult.A19).toBe(5);  expect(gridResult.B19).toBe(0);
-    expect(gridResult.A20).toBe(2);  expect(gridResult.B20).toBe(0);
-
-    expect(gridResult.A22).toBe(0);  expect(gridResult.B22).toBe(0);
-    expect(gridResult.A23).toBe(8);  expect(gridResult.B23).toBe(0);
-
-    expect(gridResult.A25).toBe(0);  expect(gridResult.B25).toBe(8);
-    expect(gridResult.A26).toBe(0);  expect(gridResult.B26).toBe(0);
-
-    expect(gridResult.A28).toBe(0);  expect(gridResult.B28).toBe(4);
-    expect(gridResult.A29).toBe(0);  expect(gridResult.B29).toBe(4);
-
-    expect(gridResult.A31).toBe(0);  expect(gridResult.B31).toBe(3);
-    expect(gridResult.A32).toBe(0);  expect(gridResult.B32).toBe(5);
-
-    expect(gridResult.A34).toBe(0);  expect(gridResult.B34).toBe(4); // @compatibility: on google sheet, return 3
-    expect(gridResult.A35).toBe(0);  expect(gridResult.B35).toBe(4); // @compatibility: on google sheet, return 5
-
-    expect(gridResult.A37).toBe(7);  expect(gridResult.B37).toBe(8);
-  });
-
-  test("COUNTIF: operator tests on type boolean", () => {
-    expect(evaluateCell("A41", { A41: "=COUNTIF(A39, TRUE)", A39: "TRUE" })).toBe(1);
-    expect(evaluateCell("A42", { A42: '=COUNTIF(A39, "TRUE")', A39: "TRUE" })).toBe(1);
-    expect(evaluateCell("A43", { A43: '=COUNTIF(A39, "=TRUE")', A39: "TRUE" })).toBe(1);
-
-    expect(evaluateCell("B41", { B41: "=COUNTIF(B39, TRUE)", B39: '="TRUE"' })).toBe(0);
-    expect(evaluateCell("B42", { B42: '=COUNTIF(B39, "TRUE")', B39: '="TRUE"' })).toBe(0);
-    expect(evaluateCell("B43", { B43: '=COUNTIF(B39, "=TRUE")', B39: '="TRUE"' })).toBe(0);
-  });
-
-  test("COUNTIF: operator tests on criterion expression", () => {
-    const grid1 = {
-      A45: "abc",
-      A46: "abd",
-      A47: "bcd",
-      A48: "b~e",
-      A49: "x*y",
-      A50: "x?z",
-      A51: "zZz",
-      A52: "zzz",
-
-      C45: '=COUNTIF(A45:A52, "abd")',
-      C46: '=COUNTIF(A45:A52, "ab")',
-      C47: '=COUNTIF(A45:A52, "=abd")',
-      C48: '=COUNTIF(A45:A52, "<abd")',
-      C49: '=COUNTIF(A45:A52, ">abd")',
-      C50: '=COUNTIF(A45:A52, "<>abd")',
-      C51: '=COUNTIF(A45:A52, "><abd")',
-
-      D45: '=COUNTIF(A45:A52, "ab*")',
-      D46: '=COUNTIF(A45:A52, "a*")',
-      D47: '=COUNTIF(A45:A52, "a*c")',
-      D48: '=COUNTIF(A45:A52, "a?")',
-      D49: '=COUNTIF(A45:A52, "a?c")',
-      D50: '=COUNTIF(A45:A52, "zzz")',
-      D51: '=COUNTIF(A45:A52, "x*z")',
-      D52: '=COUNTIF(A45:A52, "x~*z")',
-      D53: '=COUNTIF(A45:A52, "x~*y")',
-      D54: '=COUNTIF(A45:A52, "x?y")',
-      D55: '=COUNTIF(A45:A52, "x~?y")',
-      D56: '=COUNTIF(A45:A52, "x~?z")',
-      D57: '=COUNTIF(A45:A52, "b~e")',
-    };
-
-    const grid1Result = evaluateGrid(grid1);
-
-    expect(grid1Result.C45).toBe(1);
-    expect(grid1Result.C46).toBe(0);
-    expect(grid1Result.C47).toBe(1);
-    expect(grid1Result.C48).toBe(1);
-    expect(grid1Result.C49).toBe(6);
-    expect(grid1Result.C50).toBe(7);
-    expect(grid1Result.C51).toBe(8);
-
-    expect(grid1Result.D45).toBe(2);
-    expect(grid1Result.D46).toBe(2);
-    expect(grid1Result.D47).toBe(1);
-    expect(grid1Result.D48).toBe(0);
-    expect(grid1Result.D49).toBe(1);
-    expect(grid1Result.D50).toBe(2);
-    expect(grid1Result.D51).toBe(1);
-    expect(grid1Result.D52).toBe(0);
-    expect(grid1Result.D53).toBe(1);
-    expect(grid1Result.D54).toBe(1);
-    expect(grid1Result.D55).toBe(0);
-    expect(grid1Result.D56).toBe(1);
-    expect(grid1Result.D57).toBe(1);
-
-    const grid2 = {
-      A59: "abc",
-      A60: "abd",
-      A61: "abe",
-      A62: "bcd",
-      A63: "bce",
-      A64: "b$f",
-      A65: "b",
-      A66: "cdf",
-      A67: "cdg",
-
-      C59: '=COUNTIF(A59:A67, "> bcf")',
-      C60: '=COUNTIF(A59:A67, ">bcf")',
-      C61: '=COUNTIF(A59:A67, ">b?f")',
-      C62: '=COUNTIF(A59:A67, ">c*")',
-
-      E59: '=COUNTIF(A59:A67, ">b?e")',
-      E60: '=COUNTIF(A59:A67, "<b?e")',
-
-      E62: '=COUNTIF(A59:A67, ">b*e")',
-      E63: '=COUNTIF(A59:A67, "<b*e")',
-
-      E65: '=COUNTIF(A59:A67, ">b*")',
-      E66: '=COUNTIF(A59:A67, "<b*")',
-
-      F65: '=COUNTIF(A59:A67, ">b")',
-      F66: '=COUNTIF(A59:A67, "<b")',
-    };
-
-    const grid2Result = evaluateGrid(grid2);
-
-    expect(grid2Result.C59).toBe(9);
-    expect(grid2Result.C60).toBe(2);
-    expect(grid2Result.C61).toBe(4);
-    expect(grid2Result.C62).toBe(2);
-
-    expect(grid2Result.E59).toBe(4);
-    expect(grid2Result.E60).toBe(5);
-
-    expect(grid2Result.E62).toBe(4);
-    expect(grid2Result.E63).toBe(5);
-
-    expect(grid2Result.E65).toBe(4);
-    expect(grid2Result.E66).toBe(5);
-
-    expect(grid2Result.F65).toBe(5);
-    expect(grid2Result.F66).toBe(3);
-
-    const grid3 = {
-      A69: "b$f",
-
-      C69: '=COUNTIF(A69, ">b?f")',
-      C70: '=COUNTIF(A69, ">b*f")',
-      C71: '=COUNTIF(A69, ">b#f")',
-      C72: '=COUNTIF(A69, ">b&f")',
-
-      D69: '=COUNTIF(A69, "<b?f")',
-      D70: '=COUNTIF(A69, "<b*f")',
-      D71: '=COUNTIF(A69, "<b#f")',
-      D72: '=COUNTIF(A69, "<b&f")',
-    };
-
-    const grid3Result = evaluateGrid(grid3);
-
-    expect(grid3Result.C69).toBe(0);
-    expect(grid3Result.C70).toBe(0);
-    expect(grid3Result.C71).toBe(1);
-    expect(grid3Result.C72).toBe(0);
-
-    expect(grid3Result.D69).toBe(1);
-    expect(grid3Result.D70).toBe(1);
-    expect(grid3Result.D71).toBe(0);
-    expect(grid3Result.D72).toBe(1);
-
-    const grid4 = {
-      A74: "ab",
-      A75: "abc",
-      A76: "abcd",
-      A77: "abcde",
-
-      C74: '=COUNTIF(A74:A77, "a")',
-      C75: '=COUNTIF(A74:A77, "ab")',
-
-      E74: '=COUNTIF(A74:A77, "*")',
-      E75: '=COUNTIF(A74:A77, "a*")',
-      E76: '=COUNTIF(A74:A77, "ab*")',
-      E77: '=COUNTIF(A74:A77, "abc*")',
-
-      G74: '=COUNTIF(A74:A77, "?")',
-      G75: '=COUNTIF(A74:A77, "a?")',
-      G76: '=COUNTIF(A74:A77, "ab?")',
-      G77: '=COUNTIF(A74:A77, "abc?")',
-    };
-
-    const grid4Result = evaluateGrid(grid4);
-
-    expect(grid4Result.C74).toBe(0);
-    expect(grid4Result.C75).toBe(1);
-
-    expect(grid4Result.E74).toBe(4);
-    expect(grid4Result.E75).toBe(4);
-    expect(grid4Result.E76).toBe(4);
-    expect(grid4Result.E77).toBe(3);
-
-    expect(grid4Result.G74).toBe(0);
-    expect(grid4Result.G75).toBe(1);
-    expect(grid4Result.G76).toBe(1);
-    expect(grid4Result.G77).toBe(1);
-
-    const grid5 = {
-      J73: "aslnlsngj",
-
-      J74: '=COUNTIF(J73, "a*d")',
-      J75: '=COUNTIF(J73, "a*j")',
-      J76: '=COUNTIF(J73, "a*g")',
-      J77: '=COUNTIF(J73, "a*gj")',
-      J78: '=COUNTIF(J73, "a*nl*")',
-      J79: '=COUNTIF(J73, "a*nl*?n*j")',
-
-      J80: '=COUNTIF(J73, "<>*")',
-      J81: '=COUNTIF(J73, "<>a*")',
-      J82: '=COUNTIF(J73, "<>a*b")',
-    };
-
-    const grid5Result = evaluateGrid(grid5);
-
-    expect(grid5Result.J74).toBe(0);
-    expect(grid5Result.J75).toBe(1);
-    expect(grid5Result.J76).toBe(0);
-    expect(grid5Result.J77).toBe(1);
-    expect(grid5Result.J78).toBe(1);
-    expect(grid5Result.J79).toBe(1);
-
-    expect(grid5Result.J80).toBe(0);
-    expect(grid5Result.J81).toBe(0);
-    expect(grid5Result.J82).toBe(1);
-  });
-
-  //----------------------------------------------------------------------------
-  // COUNTIFS
-  //----------------------------------------------------------------------------
-
-  test("COUNTIFS: functional tests on range", () => {
-    // prettier-ignore
-    const grid = {
-      A1: "Jim"  , B1: "MN", C1: "100",
-      A2: "Sarah", B2: "CA", C2: "125",
-      A3: "Jane" , B3: "GA", C3: "200",
-      A4: "Steve", B4: "CA", C4: "50" ,
-      A5: "Jim"  , B5: "WY", C5: "75" ,
-      A6: "Joan" , B6: "WA", C6: "150",
-      A7: "Jane" , B7: "GA", C7: "200",
-      A8: "Jim"  , B8: "WY", C8: "50" ,
-
-      D1: '=COUNTIFS(A1:A8, "JIM", B1:B8, "??" , C1:C8, ">=100")',
-      D2: '=COUNTIFS(A1:A8, "JIM", B1:B8, "??" , C1:C8, ">=50")',
-      D3: '=COUNTIFS(A1:A8, "JIM", B1:B8, "WY" , C1:C8, ">=50")',
-      D4: '=COUNTIFS(A1:A8, "J*" , B1:B8, "W?" , C1:C8, ">=50")',
-      D5: '=COUNTIFS(A1:A8, "J*" , B1:B8, "?A" , C1:C8, ">=50")',
-      D6: '=COUNTIFS(A1:A8, "J*" , B1:B8, "?A" , C1:C8, "<>200")',
-      D7: '=COUNTIFS(A1:A8, "J*" , B1:B8, "*"  , C1:C8, "50")',
-      D8: '=COUNTIFS(A1:A8, "*a*", B1:B8, "*a*", C1:C8, ">0")',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.D1).toBe(1);
-    expect(gridResult.D2).toBe(3);
-    expect(gridResult.D3).toBe(2);
-    expect(gridResult.D4).toBe(3);
-    expect(gridResult.D5).toBe(3);
-    expect(gridResult.D6).toBe(1);
-    expect(gridResult.D7).toBe(1);
-    expect(gridResult.D8).toBe(4);
-  });
-
-  //----------------------------------------------------------------------------
-  // COUNTUNIQUE
-  //----------------------------------------------------------------------------
-
-  test("COUNTUNIQUE: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=countunique()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=countunique(,)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=countunique(0)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(1, 2, 3, 1, 2)" })).toBe(3);
-    expect(evaluateCell("A1", { A1: "=countunique(1,  , 2,  , 3)" })).toBe(3);
-    expect(evaluateCell("A1", { A1: "=countunique(1.5, 1.4)" })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique("Jean Saisrien", "Jean Prendnote")' })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique("")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=countunique(" ")' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique("2", "-2")' })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique("2", "")' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique("2", " ")' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(TRUE, FALSE)" })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique(1, "1", TRUE)' })).toBe(3);
-  });
-
-  test("COUNTUNIQUE: functional tests on cell arguments", () => {
-    expect(evaluateCell("A1", { A1: "=countunique(A2)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=countunique(A2)", A2: " " })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2)", A2: "," })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2)", A2: "0" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "1", A3: "2" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3, A4)", A2: "1", A3: "", A4: "1" })).toBe(
-      1
-    );
-    expect(
-      evaluateCell("A1", {
-        A1: "=countunique(A2, A3, A4)",
-        A2: "1.4",
-        A3: "-1",
-        A4: "Jean Peuxplus",
-      })
-    ).toBe(3);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: " ", A3: "" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "", A3: '=" "' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: " ", A3: '=" "' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "  ", A3: '=" "' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: " ", A3: '="  "' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "42", A3: "42" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "42", A3: '"42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "42", A3: "=42" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "42", A3: '="42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: '"42"', A3: '"42"' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: '"42"', A3: "=42" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: '"42"', A3: '="42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "=42", A3: "=42" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: "=42", A3: '="42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, A3)", A2: '="42"', A3: '="42"' })).toBe(1);
-  });
-
-  test("COUNTUNIQUE: functional tests on simple and cell arguments", () => {
-    expect(evaluateCell("A1", { A1: "=countunique(A2,)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=countunique(A2,)", A2: " " })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2,)", A2: '=""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=countunique(A2,)", A2: '=" "' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "")', A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "")', A2: " " })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "")', A2: '=""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "")', A2: '=" "' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, " ")', A2: "" })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, " ")', A2: " " })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, " ")', A2: '=""' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, " ")', A2: '=" "' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=countunique(42, "42")' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, 42)", A2: "42" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, 42)", A2: '"42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, 42)", A2: "=42" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, 42)", A2: '="42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "42")', A2: "42" })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "42")', A2: '"42"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "42")', A2: "=42" })).toBe(2);
-    expect(evaluateCell("A1", { A1: '=countunique(A2, "42")', A2: '="42"' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, TRUE)", A2: "1" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, TRUE)", A2: '"1"' })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, TRUE)", A2: "=1" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=countunique(A2, TRUE)", A2: '="1"' })).toBe(2);
-  });
-
-  test("COUNTUNIQUE: functional tests on range arguments", () => {
-    const grid = {
-      A1: "=COUNTUNIQUE(B2:D3,B4:D4,E2:E3,E4)",
-
-      A2: "=COUNTUNIQUE(B2:E2)",
-      A3: "=COUNTUNIQUE(B3:E3)",
-      A4: "=COUNTUNIQUE(B4:E4)",
-
-      B1: "=COUNTUNIQUE(B2:B4)",
-      C1: "=COUNTUNIQUE(C2:C4)",
-      D1: "=COUNTUNIQUE(D2:D4)",
-      E1: "=COUNTUNIQUE(E2:E4)",
-
-      B2: "=3",
-      C2: "3",
-      D2: '"3"',
-      E2: '="3"',
-
-      B3: '=" "',
-      C3: "0",
-      D3: "Jean Registre",
-      E3: '"Jean Titouplin"',
-
-      B4: " ",
-      C4: '""',
-      D4: '=""',
-      E4: '" "',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.A1).toBe(9);
-    expect(gridResult.A2).toBe(3);
-    expect(gridResult.A3).toBe(4);
-    expect(gridResult.A4).toBe(3);
-    expect(gridResult.B1).toBe(2);
-    expect(gridResult.C1).toBe(3);
-    expect(gridResult.D1).toBe(2);
-    expect(gridResult.E1).toBe(3);
-  });
-
-  //----------------------------------------------------------------------------
-  // COUNTUNIQUEIFS
-  //----------------------------------------------------------------------------
-
-  test("COUNTUNIQUEIFS: functional tests on range", () => {
-    // prettier-ignore
-    const grid = {
-      A1:  "car"   , B1:  "4" , C1:  "14", D1:  "Yes",
-      A2:  "toy"   , B2:  "28", C2:  "30", D2:  "Yes",
-      A3:  "shirt" , B3:  "31", C3:  "47", D3:  "Yes",
-      A4:  "car"   , B4:  "12", C4:  "0" , D4:  "Yes",
-      A5:  "toy"   , B5:  "31", C5:  "47", D5:  "Yes",
-      A6:  "milk"  , B6:  "13", C6:  "5" , D6:  "No" ,
-      A7:  "butter", B7:  "18", C7:  "43", D7:  "No" ,
-      A8:  "shirt" , B8:  "24", C8:  "7" , D8:  "Yes",
-      A9:  "car"   , B9:  "44", C9:  "28", D9:  "No" ,
-      A10: '=""'   , B10: "22", C10: "23", D10: "No" ,
-                     B11: "9" , C11: "13", D11: "No" ,
-
-      A12: '=COUNTUNIQUEIFS(A1:A11, B1:B11, ">20")',
-      A13: '=COUNTUNIQUEIFS(A1:A11, B1:B11, ">20", C1:C11, "<30")',
-      A14: '=COUNTUNIQUEIFS(A1:A11, D1:D11, "No")',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.A12).toBe(3);
-    expect(gridResult.A13).toBe(2);
-    expect(gridResult.A14).toBe(3);
-  });
-
-  //----------------------------------------------------------------------------
-  // CSC
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["=3*PI()/2", -1],
-    ["=PI()/2", 1],
-    ["=-PI()/2", -1],
-    ["1", 1.188395106],
-    ["-2", -1.09975017],
-  ])("CSC(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=CSC(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0"]])("CSC(%s) - ERROR: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=CSC(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-  });
-
-  //----------------------------------------------------------------------------
-  // CSCH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", 0.850918128],
-    ["-2", -0.275720565],
-    ["=LN(3)", 0.75],
-    ["=-LN(9)", -0.225],
-  ])("CSCH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=CSCH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0"]])("CSCH(%s) - ERROR: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=CSCH(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-  });
-
-  //----------------------------------------------------------------------------
-  // DECIMAL
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", "2", 0],
-    ["0", "4", 0],
-    ["0", "36", 0],
-    ["1010", "2", 10],
-    ["1010", "4", 68],
-    ["1010", "36", 46692],
-    ["2020", "36", 93384],
-    ["3030", "4", 204],
-    ["-1010", "16", -4112], // @compatibility: return error on parameter 1 on google sheets
-    ["ABAB", "16", 43947],
-    ["ABAB", "36", 481187],
-    ["A1A1", "16", 41377],
-    ["a1a1", "16", 41377],
-    ["a1a1", "36", 468217],
-    ["-ABAB", "16", -43947], // @compatibility: return error on parameter 1 on google sheets
-    ["-ABAB", "36", -481187], // @compatibility: return error on parameter 1 on google sheets
-    ["zzzz", "36", 1679615],
-  ])("DECIMAL(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test.each([
-    ["1010", "-1"],
-    ["1010", "0"],
-    ["1010", "0.1"],
-    ["1010", "1"],
-    ["1010", "37"],
-    ["-", "2"],
-    ["A-", "36"],
-    ["@ABAB", "36"],
-    ["AB AB", "36"],
-  ])("DECIMAL(%s, %s) - error: take 2 parameter(s), return error on parameter 2", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-  });
-
-  test.each([
-    ["0.1", "2"],
-    ["2020", "2"],
-    ["-ABAB", "2"],
-    ["-ABAB", "10"],
-    ["ZZZZ", "16"],
-    ["-", "36"],
-    ["A-", "36"],
-    ["@ABAB", "36"],
-    ["ABAB@", "36"],
-    ["ABAB.2", "36"],
-    ["ABAB.21@", "36"],
-    ["AB AB", "36"],
-  ])("DECIMAL(%s, %s) - error: take 2 parameter(s), return error on parameter 1", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-  });
-
-  test("DECIMAL: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=DECIMAL()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=DECIMAL( , )" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(42, 12)" })).toBe(50);
-    expect(evaluateCell("A1", { A1: "=DECIMAL( , 12)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DECIMAL(42, )" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(42, TRUE)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(42, FALSE)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(TRUE, 10)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(FALSE, 10)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-
-    expect(evaluateCell("A1", { A1: '=DECIMAL("" , "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: '=DECIMAL("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=DECIMAL(" " , 12)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: '=DECIMAL("42", 12)' })).toBe(50);
-    expect(evaluateCell("A1", { A1: '=DECIMAL("42", "12")' })).toBe(50);
-    expect(evaluateCell("A1", { A1: '=DECIMAL("42", "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "", A3: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "42", A3: "12" })).toBe(50);
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "", A3: "12" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "42", A3: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "42", A3: "TRUE" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "42", A3: "FALSE" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "42", A3: "FALSE" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "TRUE", A3: "10" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: "FALSE", A3: "10" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: '"42"', A3: '"12"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DECIMAL(A2, A3)", A2: '="42"', A3: '="36"' })).toBe(146);
-  });
-
-  //----------------------------------------------------------------------------
-  // DEGREES
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-5", -286.4788975654116], // @compatibility: on google sheets return -286.47889756541(2) and not (16)
-    ["-3.14", -179.90874767107852], // @compatibility: on google sheets return -179.90874767107(9) and not (852)
-    ["0", 0],
-    ["3.14", 179.90874767107852], // @compatibility: on google sheets return 179.90874767107(9) and not (852)
-    ["5", 286.4788975654116], // @compatibility: on google sheets return 286.47889756541(2) and not (16)
-    ["=-PI()", -180],
-    ["=PI()", 180],
-    ["=PI() * 3", 540],
-    ["3.141592653589793", 180],
-    ["3.14159265358979", 179.99999999999983], // @compatibility: on google sheets return 180
-    ["3.1415926535897", 179.99999999999466], // @compatibility: on google sheets return 179.99999999999(5) and not (466)
-  ])("DEGREES(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: a })).toBe(expected);
-  });
-
-  test("DEGREES: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=DEGREES()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=DEGREES(0)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DEGREES(PI())" })).toBe(180);
-    expect(evaluateCell("A1", { A1: "=DEGREES(TRUE)" })).toBeCloseTo(57.29577951, 8);
-    expect(evaluateCell("A1", { A1: "=DEGREES(FALSE)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=DEGREES("")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=DEGREES(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=DEGREES("hello there")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: "0" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: "=PI()" })).toBe(180);
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: "TRUE" })).toBeCloseTo(57.29577951, 8);
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: "FALSE" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: '=""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=DEGREES(A2)", A2: '="0"' })).toBe(0);
-  });
-
-  //----------------------------------------------------------------------------
-  // EXP
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", Math.exp(1)],
-    ["=LN(1)", 1],
-    ["0", 1],
-    ["-1", 0.3678794412],
-    ["2", 7.389056099],
-  ])("EXP(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test("EXP: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=EXP()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=EXP(TRUE)" })).toBeCloseTo(Math.exp(1), 9);
-    expect(evaluateCell("A1", { A1: "=EXP(FALSE)" })).toBeCloseTo(1, 9);
-
-    expect(evaluateCell("A1", { A1: '=EXP("")' })).toBeCloseTo(1, 9);
-    expect(evaluateCell("A1", { A1: '=EXP(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=EXP("1")' })).toBeCloseTo(Math.exp(1), 9);
-
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: "" })).toBeCloseTo(1, 9);
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: "1" })).toBeCloseTo(Math.exp(1), 9);
-
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: '"1"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: '=""' })).toBeCloseTo(1, 9);
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=EXP(A2)", A2: '="1"' })).toBeCloseTo(Math.exp(1), 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // FLOOR / FLOOR.MATH / FLOOR.PRECISE
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 0],
-    ["6", 6],
-    ["6.7", 6],
-    ["7.89", 7],
-    ["-6", -6],
-    ["-6.7", -7],
-    ["-7.89", -8],
-  ])("FLOOR FUNCTIONS(%s) - %s: take 1 parameters, return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=FLOOR(A2)", A2: a })).toBe(expected);
-    expect(evaluateCell("A1", { A1: "=FLOOR.MATH(A2)", A2: a })).toBe(expected);
-    expect(evaluateCell("A1", { A1: "=FLOOR.PRECISE(A2)", A2: a })).toBe(expected);
-  });
-
-  test.each([
-    ["0", "0", 0],
-    ["0", "0.1", 0],
-    ["0", "-4", 0],
-    ["6", "0", 0], // @compatibility on google sheets: concerning basic floor function, return error div by 0
-    ["6.7", "0", 0], // @compatibility on google sheets: concerning basic floor function, return error div by 0
-    ["-6", "0", 0], // @compatibility on google sheets: concerning basic floor function, return error div by 0
-    ["6", "0.1", 6],
-    ["-6", "0.1", -6],
-    ["6", "0.7", 5.6],
-    ["-6", "0.7", -6.3],
-    ["6.7", "0.2", 6.6],
-    ["-6.7", "0.2", -6.8],
-  ])("FLOOR FUNCTIONS(%s, %s) - %s: take 2 parameters, return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=FLOOR(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected);
-    expect(evaluateCell("A1", { A1: "=FLOOR.MATH(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected);
-    expect(evaluateCell("A1", { A1: "=FLOOR.PRECISE(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-      expected
-    );
-  });
-
-  test.each([
-    ["0", "0.2", 0],
-    ["0", "-0.2", 0],
-    ["7.89", "0.2", 7.8],
-    ["7.89", "-0.2", 7.8],
-    ["-7.89", "0.2", -8],
-    ["-7.89", "-0.2", -8],
-  ])(
-    "FLOOR (MATH/PRECISE) FUNCTIONS(%s, %s) - %s: no effect with negative factor",
-    (a, b, expected) => {
-      expect(evaluateCell("A1", { A1: "=FLOOR.MATH(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected);
-      expect(evaluateCell("A1", { A1: "=FLOOR.PRECISE(A2, A3)", A2: a, A3: b })).toBeCloseTo(
-        expected
-      );
-    }
-  );
-
-  test.each([
-    ["6", "-0.2"],
-    ["7.89", "-0.2"],
-  ])("FLOOR(%s, %s) - error: if value positive, factor can't be negative", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=FLOOR(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-  });
-
-  test.each([
-    // Concerning FLOOR function
-    // if "a" is negative and "b" is negative, rounds a number up (and not down)
-    // the nearest integer multiple of b
-    ["-7.89", "0.2", -8],
-    ["-7.89", "-0.2", -7.8],
-  ])("FLOOR(%s, %s) - %s: if factor negative, rouds number down", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=FLOOR(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([
-    // Concerning FLOOR.MATH function
-    // if "a" is negative and "c" different 0, rounds a number up (and not down)
-    // the nearest integer multiple of b
-    ["7.89", "0.2", "0", 7.8],
-    ["7.89", "0.2", "1", 7.8],
-    ["-7.89", "0.2", "0", -8],
-    ["-7.89", "0.2", "1", -7.8],
-    ["-7.89", "0.2", "2.2", -7.8],
-    ["-7.89", "0.2", "-2.2", -7.8],
-    ["-7.89", "-0.2", "0", -8],
-    ["-7.89", "-0.2", "1", -7.8],
-    ["-7.89", "-0.2", "2.2", -7.8],
-    ["-7.89", "-0.2", "-2.2", -7.8],
-  ])("FLOOR.MATH(%s, %s, %s) - %s: take 3 parameters, return a number", (a, b, c, expected) => {
-    expect(evaluateCell("A1", { A1: "=FLOOR.MATH(A2, A3, A4)", A2: a, A3: b, A4: c })).toBeCloseTo(
-      expected,
-      9
-    );
-  });
-
-  function evaluateFloorFunction(functionName: string): void {
-    expect(evaluateCell("A1", { A1: "=" + functionName + "()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=" + functionName + "( , )" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, 0.2)" })).toBeCloseTo(-8, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "( , 0.2)" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, )" })).toBeCloseTo(0, 9); // @compatibility: on google sheets, return -8
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, TRUE)" })).toBeCloseTo(-8, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(-7.89, FALSE)" })).toBeCloseTo(0, 9); // @compatibility on google sheets: concerning basic floor function, return error div by 0
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(TRUE, 10)" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(FALSE, 10)" })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=" + functionName + '("" , "")' })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=" + functionName + '(" " , " ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=" + functionName + '("-7.89", "0.2")' })).toBeCloseTo(-8, 9);
-
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "", A3: "" })).toBeCloseTo(
-      0,
-      9
-    );
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: " ", A3: " " })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "0.2" })
-    ).toBeCloseTo(-8, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "", A3: "0.2" })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "" })
-    ).toBeCloseTo(0, 9); // @compatibility on google sheets: concerning basic floor function, return error div by 0
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "TRUE" })
-    ).toBeCloseTo(-8, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "-7.89", A3: "FALSE" })
-    ).toBeCloseTo(0, 9); // @compatibility on google sheets: concerning basic floor function, return error div by 0
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "TRUE", A3: "10" })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: "FALSE", A3: "10" })
-    ).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '""', A3: '""' })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '" "', A3: '" "' })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '"-7.89"', A3: '"0.2"' })
-    ).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '=""', A3: '=""' })
-    ).toBeCloseTo(0, 9);
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '=" "', A3: '=" "' })
-    ).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(
-      evaluateCell("A1", { A1: "=" + functionName + "(A2, A3)", A2: '="-7.89"', A3: '="0.2"' })
-    ).toBeCloseTo(-8, 9);
-  }
-
-  test.each([["FLOOR"], ["FLOOR.MATH"], ["FLOOR.PRECISE"]])(
-    "%s: special value testing",
-    (functionName) => {
-      evaluateFloorFunction(functionName);
-    }
-  );
-
-  //----------------------------------------------------------------------------
-  // ISEVEN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-3", false],
-    ["-2.3", true],
-    ["-2", true],
-    ["0", true],
-    ["2", true],
-    ["2.3", true],
-    ["3", false],
-  ])("ISEVEN(%s) - %s: take 1 parameter(s), return a boolean", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: a })).toBe(expected);
-  });
-
-  test("ISEVEN: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=ISEVEN()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ISEVEN(0)" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(1)" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(TRUE)" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(FALSE)" })).toBe(true);
-
-    expect(evaluateCell("A1", { A1: '=ISEVEN("")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ISEVEN(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ISEVEN("hello there")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: "" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: "0" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: "1" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: "TRUE" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: "FALSE" })).toBe(true);
-
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISEVEN(A2)", A2: '="0"' })).toBe(true);
-  });
-
-  //----------------------------------------------------------------------------
-  // ISODD
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-3", true],
-    ["-2.2", false],
-    ["-2", false],
-    ["0", false],
-    ["2", false],
-    ["2.3", false],
-    ["3", true],
-  ])("ISODD(%s) - %s: take 1 parameter(s), return a boolean", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: a })).toBe(expected);
-  });
-
-  test("ISODD: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=ISODD()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ISODD(0)" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISODD(1)" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISODD(TRUE)" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISODD(FALSE)" })).toBe(false);
-
-    expect(evaluateCell("A1", { A1: '=ISODD("")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ISODD(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ISODD("hello there")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: "" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: "0" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: "1" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: "TRUE" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: "FALSE" })).toBe(false);
-
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ISODD(A2)", A2: '="0"' })).toBe(false);
-  });
-
-  //----------------------------------------------------------------------------
-  // LN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", 0],
-    ["=EXP(1)", 1],
-    ["2", 0.6931471806],
-    ["9", Math.log(3) + Math.log(3)],
-  ])("LN(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([["0"], ["-42"]])("LN(%s) - %s: take 1 parameter(s), return an error", (a) => {
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-  });
-
-  test("LN: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=LN()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=LN(TRUE)" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=LN(FALSE)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-
-    expect(evaluateCell("A1", { A1: '=LN("")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: '=LN(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=LN("1")' })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: "1" })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: '"1"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=LN(A2)", A2: '="1"' })).toBeCloseTo(0, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // MOD
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-42", "-10", -2],
-    ["-42", "-2.2", -0.2],
-    ["-42", "-2", 0],
-    ["-42", "2", 0],
-    ["-42", "2.2", 2],
-    ["-42", "10", 8],
-    ["0", "-10", 0],
-    ["0", "-2.2", 0],
-    ["0", "-2", 0],
-    ["0", "2", 0],
-    ["0", "2.2", 0],
-    ["0", "10", 0],
-    ["2.2", "-10", -7.8],
-    ["2.2", "-2.2", 0],
-    ["2.2", "-2", -1.8],
-    ["2.2", "2", 0.2],
-    ["2.2", "2.2", 0],
-    ["2.2", "10", 2.2],
-  ])("MOD(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: a, A3: b })).toBeCloseTo(expected, 9);
-  });
-
-  test.each([
-    ["-42", "0"],
-    ["0", "0"],
-    ["2.2", "0"],
-  ])("MOD(%s, %s) - error: take 2 parameter(s), return error on parameter 2", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-  });
-
-  test("MOD: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=MOD()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=MOD( , )" })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: "=MOD(42, 12)" })).toBe(6);
-    expect(evaluateCell("A1", { A1: "=MOD( , 12)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=MOD(42, )" })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: "=MOD(42.42, TRUE)" })).toBeCloseTo(0.42, 9);
-    expect(evaluateCell("A1", { A1: "=MOD(42, FALSE)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: "=MOD(TRUE, 10)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=MOD(FALSE, 10)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=MOD("" , "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: '=MOD("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=MOD(" " , 12)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=MOD("42", 12)' })).toBe(6);
-    expect(evaluateCell("A1", { A1: '=MOD("42", "12")' })).toBe(6);
-    expect(evaluateCell("A1", { A1: '=MOD("42", "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "", A3: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "42", A3: "12" })).toBe(6);
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "", A3: "12" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "42", A3: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "42.42", A3: "TRUE" })).toBeCloseTo(
-      0.42,
-      9
-    );
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "42.42", A3: "FALSE" })).toBe("#ERROR"); // @compatibility: on google sheets, return #DIV/0!
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "TRUE", A3: "10" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: "FALSE", A3: "10" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: '"42"', A3: '"12"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=MOD(A2, A3)", A2: '="42"', A3: '="36"' })).toBe(6);
-  });
-
-  //----------------------------------------------------------------------------
-  // ODD
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-3.9", -5],
-    ["-3.1", -5],
-    ["-3", -3],
-    ["-2.9", -3],
-    ["-2.1", -3],
-    ["-2", -3],
-    ["0", 1],
-    ["2", 3],
-    ["2.1", 3],
-    ["2.9", 3],
-    ["3", 3],
-    ["3.1", 5],
-    ["3.9", 5],
-  ])("ODD(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: a })).toBe(expected);
-  });
-
-  test("ODD: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=ODD()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ODD(0)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ODD(2)" })).toBe(3);
-    expect(evaluateCell("A1", { A1: "=ODD(TRUE)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ODD(FALSE)" })).toBe(1);
-
-    expect(evaluateCell("A1", { A1: '=ODD("")' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=ODD(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ODD("hello there")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: "" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: "0" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: "2" })).toBe(3);
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: "TRUE" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: "FALSE" })).toBe(1);
-
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: '=""' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=ODD(A2)", A2: '="42"' })).toBe(43);
-  });
-
-  //----------------------------------------------------------------------------
-  // PI
-  //----------------------------------------------------------------------------
-
-  test("PI", () => {
-    expect(evaluateCell("A1", { A1: "=PI()" })).toBeCloseTo(Math.PI, 9); // @compatibility: on google sheets return 3.14159265358979
-  });
-
-  //----------------------------------------------------------------------------
-  // POWER
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", "0", 1],
-    ["0", "0.5", 0],
-    ["4", "0", 1],
-    ["0", "4", 0],
-    ["4", "2", 16],
-    ["-4", "2", 16],
-    ["4", "3", 64],
-    ["-4", "3", -64],
-    ["4", "0.5", 2],
-    ["4", "-0.5", 0.5],
-    ["4", "-2", 0.0625],
-  ])("POWER(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test.each([
-    ["-4", "0.5"],
-    ["-4", "1.5"],
-    ["-4", "0.2"],
-  ])("POWER(%s, %s) - error: take 2 parameter(s), return an error on parameter 2", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-  });
-
-  test("POWER: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=POWER()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=POWER( , )" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(42, 2)" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=POWER( , 12)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=POWER(42, )" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(42.42, TRUE)" })).toBe(42.42);
-    expect(evaluateCell("A1", { A1: "=POWER(42.42, FALSE)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(TRUE, 10)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(FALSE, 10)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=POWER("" , "")' })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=POWER("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=POWER(" " , 12)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=POWER("42", 2)' })).toBe(1764);
-    expect(evaluateCell("A1", { A1: '=POWER("42", "2")' })).toBe(1764);
-    expect(evaluateCell("A1", { A1: '=POWER("42", "")' })).toBe(1);
-
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "", A3: "" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "42", A3: "2" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "", A3: "12" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "42", A3: "" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "42.42", A3: "TRUE" })).toBe(42.42);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "42.42", A3: "FALSE" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "TRUE", A3: "10" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: "FALSE", A3: "10" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: '"42"', A3: '"12"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=POWER(A2, A3)", A2: '="42"', A3: '="2"' })).toBe(1764);
-  });
-
-  //----------------------------------------------------------------------------
-  // PRODUCT
-  //----------------------------------------------------------------------------
-
-  test("PRODUCT: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=PRODUCT()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=PRODUCT(,)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(0)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(1, 2, 3, 1, 2)" })).toBe(12);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(1,  , 2,  , 3)" })).toBe(6);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(1.5, 1.4)" })).toBeCloseTo(2.1);
-    expect(evaluateCell("A1", { A1: '=PRODUCT("Jean Chante", "Jean Courage")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT("")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT("2", "-2")' })).toBe(-4);
-    expect(evaluateCell("A1", { A1: '=PRODUCT("2", "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT("2", " ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=PRODUCT(TRUE, FALSE)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=PRODUCT(1, "1", TRUE)' })).toBe(1);
-  });
-
-  test("PRODUCT: functional tests on cell arguments", () => {
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2)", A2: " " })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2)", A2: "," })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2)", A2: "0" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "1", A3: "2" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3, A4)", A2: "1", A3: "", A4: "1" })).toBe(1);
-    expect(
-      evaluateCell("A1", { A1: "=PRODUCT(A2, A3, A4)", A2: "1.5", A3: "-10", A4: "Jean Brasse" })
-    ).toBe(-15);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: " ", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "", A3: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: " ", A3: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "  ", A3: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: " ", A3: '="  "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "42", A3: "42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "42", A3: '"42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "42", A3: "=42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "42", A3: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: '"42"', A3: '"42"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: '"42"', A3: "=42" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: '"42"', A3: '="42"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "=42", A3: "=42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: "=42", A3: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, A3)", A2: '="42"', A3: '="42"' })).toBe(0);
-  });
-
-  test("PRODUCT: functional tests on simple and cell arguments", () => {
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2,)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2,)", A2: " " })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2,)", A2: '=""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2,)", A2: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "")', A2: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "")', A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "")', A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "")', A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, " ")', A2: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, " ")', A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, " ")', A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, " ")', A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=PRODUCT(42, "42")' })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, 42)", A2: "42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, 42)", A2: '"42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, 42)", A2: "=42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, 42)", A2: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "42")', A2: "42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "42")', A2: '"42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "42")', A2: "=42" })).toBe(1764);
-    expect(evaluateCell("A1", { A1: '=PRODUCT(A2, "42")', A2: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, TRUE)", A2: "1" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, TRUE)", A2: '"1"' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, TRUE)", A2: "=1" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=PRODUCT(A2, TRUE)", A2: '="1"' })).toBe(1);
-  });
-
-  test("PRODUCT: functional tests on range arguments", () => {
-    const grid = {
-      A1: "=PRODUCT(B2:D3,B4:D4,E2:E3,E4)",
-
-      A2: "=PRODUCT(B2:E2)",
-      A3: "=PRODUCT(B3:E3)",
-      A4: "=PRODUCT(B4:E4)",
-
-      B1: "=PRODUCT(B2:B4)",
-      C1: "=PRODUCT(C2:C4)",
-      D1: "=PRODUCT(D2:D4)",
-      E1: "=PRODUCT(E2:E4)",
-
-      B2: "=3",
-      C2: "3",
-      D2: '"3"',
-      E2: '="3"',
-
-      B3: '=" "',
-      C3: "0",
-      D3: "Jean Jardindu",
-      E3: '"Jean Fortroche"',
-
-      B4: " ",
-      C4: '""',
-      D4: '=""',
-      E4: '" "',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.A1).toBe(0);
-    expect(gridResult.A2).toBe(9);
-    expect(gridResult.A3).toBe(0);
-    expect(gridResult.A4).toBe(0);
-    expect(gridResult.B1).toBe(3);
-    expect(gridResult.C1).toBe(0);
-    expect(gridResult.D1).toBe(0);
-    expect(gridResult.E1).toBe(0);
-  });
-
-  //----------------------------------------------------------------------------
-  // RAND
-  //----------------------------------------------------------------------------
-
-  test("RAND(): return a number", () => {
-    expect(evaluateCell("A1", { A1: "=RAND()" })).toBeGreaterThanOrEqual(0);
-    expect(evaluateCell("A1", { A1: "=RAND()" })).toBeLessThan(1);
-  });
-
-  //----------------------------------------------------------------------------
-  // RANDBETWEEN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", "0", 0],
-    ["42", "42", 42],
-    ["-42", "-42", -42],
-    ["1.1", "2", 2],
-  ])("RANDBETWEEN(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test.each([
-    ["-42", "42"],
-    ["24", "42"],
-    ["-42", "-24"],
-  ])("RANDBETWEEN(%s, %s): take 2 parameter(s), return a number", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: a, A3: b })).toBeGreaterThanOrEqual(
-      toNumber(a)
-    );
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: a, A3: b })).toBeLessThanOrEqual(
-      toNumber(b)
-    );
-  });
-
-  test.each([
-    ["1.1", "1.2"], // @compatibility: on google sheets, return 2
-    ["-24", "-42"],
-    ["42", "24"],
-  ])("RANDBETWEEN(%s, %s) - error: take 2 parameter(s), return an error", (a, b) => {
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: a, A3: b })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-  });
-
-  test("RANDBETWEEN: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN( , )" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(2, 2)" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN( , 0)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(42, )" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(42.42, TRUE)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(42.42, FALSE)" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(TRUE, 1)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(FALSE, 0)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=RANDBETWEEN("" , "")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=RANDBETWEEN("" , 0)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=RANDBETWEEN(" " , 12)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=RANDBETWEEN("42", 42)' })).toBe(42);
-    expect(evaluateCell("A1", { A1: '=RANDBETWEEN("42", "42")' })).toBe(42);
-    expect(evaluateCell("A1", { A1: '=RANDBETWEEN("42", "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "2", A3: "2" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "", A3: "0" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "42", A3: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "42.42", A3: "TRUE" })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "42.42", A3: "FALSE" })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #NUM!
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "TRUE", A3: "1" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: "FALSE", A3: "0" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: '"42"', A3: '"42"' })).toBe(
-      "#ERROR"
-    ); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: '=""', A3: '="0"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=RANDBETWEEN(A2, A3)", A2: '="42"', A3: '="42"' })).toBe(42);
-  });
-
-  //----------------------------------------------------------------------------
-  // ROUND
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-1.6", -2],
-    ["-1.5", -2],
-    ["-1.4", -1],
-    ["0", 0],
-    ["1.4", 1],
-    ["1.5", 2],
-    ["1.6", 2],
-  ])("ROUND(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ROUND(A2)", A2: a })).toBe(expected);
-  });
-
-  test.each([
-    ["0.3", "2", 0.3],
-    ["0.34", "2", 0.34],
-    ["0.345", "2", 0.35],
-    ["-0.3", "2", -0.3],
-    ["-0.34", "2", -0.34],
-    ["-0.345", "2", -0.35],
-    ["0.345", "1.9", 0.3],
-    ["-0.345", "1.9", -0.3],
-    ["4", "-1", 0],
-    ["5", "-1", 10],
-    ["50", "-2", 100],
-    ["-5", "-1", -10],
-    ["-50", "-2", -100],
-    ["5", "-1.9", 10],
-    ["-5", "-1.9", -10],
-  ])("ROUND(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test("ROUND: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=ROUND()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ROUND( , )" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUND(42, -1)" })).toBe(40);
-    expect(evaluateCell("A1", { A1: "=ROUND( , 42)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUND(42, )" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=ROUND(42.42, TRUE)" })).toBe(42.4);
-    expect(evaluateCell("A1", { A1: "=ROUND(42.42, FALSE)" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=ROUND(TRUE, 10)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ROUND(FALSE, 10)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=ROUND("" , "")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=ROUND("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=ROUND(" " , 0)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ROUND("42", -1)' })).toBe(40);
-    expect(evaluateCell("A1", { A1: '=ROUND("42", "-1")' })).toBe(40);
-    expect(evaluateCell("A1", { A1: '=ROUND("42", "")' })).toBe(42);
-
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "42", A3: "-1" })).toBe(40);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "", A3: "42" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "42", A3: "" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "42.42", A3: "TRUE" })).toBe(42.4);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "42.42", A3: "FALSE" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "TRUE", A3: "10" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: "FALSE", A3: "10" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: '"42"', A3: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUND(A2, A3)", A2: '="42"', A3: '="-1"' })).toBe(40);
-  });
-
-  //----------------------------------------------------------------------------
-  // ROUNDDOWN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-1.9", -1],
-    ["-1.5", -1],
-    ["-1.4", -1],
-    ["0", 0],
-    ["1.4", 1],
-    ["1.5", 1],
-    ["1.9", 1],
-  ])("ROUNDDOWN(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2)", A2: a })).toBe(expected);
-  });
-
-  test.each([
-    ["0.3", "2", 0.3],
-    ["0.34", "2", 0.34],
-    ["0.349", "2", 0.34],
-    ["-0.3", "2", -0.3],
-    ["-0.34", "2", -0.34],
-    ["-0.349", "2", -0.34],
-    ["0.349", "1.9", 0.3],
-    ["-0.349", "1.9", -0.3],
-    ["9", "-1", 0],
-    ["19", "-1", 10],
-    ["599", "-2", 500],
-    ["-19", "-1", -10],
-    ["-599", "-2", -500],
-    ["19", "-1.9", 10],
-    ["-19", "-1.9", -10],
-  ])("ROUNDDOWN(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test("ROUNDDOWN: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN( , )" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(49, -1)" })).toBe(40);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN( , 49)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(49, )" })).toBe(49);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(49.49, TRUE)" })).toBe(49.4);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(49.49, FALSE)" })).toBe(49);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(TRUE, 10)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(FALSE, 10)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=ROUNDDOWN("" , "")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=ROUNDDOWN("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=ROUNDDOWN(" " , 0)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ROUNDDOWN("49", -1)' })).toBe(40);
-    expect(evaluateCell("A1", { A1: '=ROUNDDOWN("49", "-1")' })).toBe(40);
-    expect(evaluateCell("A1", { A1: '=ROUNDDOWN("49", "")' })).toBe(49);
-
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "49", A3: "-1" })).toBe(40);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "", A3: "49" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "49", A3: "" })).toBe(49);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "49.49", A3: "TRUE" })).toBe(49.4);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "49.49", A3: "FALSE" })).toBe(49);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "TRUE", A3: "10" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: "FALSE", A3: "10" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: '"49"', A3: '"49"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDDOWN(A2, A3)", A2: '="49"', A3: '="-1"' })).toBe(40);
-  });
-
-  //----------------------------------------------------------------------------
-  // ROUNDUP
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-1.6", -2],
-    ["-1.5", -2],
-    ["-1.1", -2],
-    ["0", 0],
-    ["1.1", 2],
-    ["1.5", 2],
-    ["1.6", 2],
-  ])("ROUNDUP(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2)", A2: a })).toBe(expected);
-  });
-
-  test.each([
-    ["0.3", "2", 0.3],
-    ["0.34", "2", 0.34],
-    ["0.341", "2", 0.35],
-    ["-0.3", "2", -0.3],
-    ["-0.34", "2", -0.34],
-    ["-0.341", "2", -0.35],
-    ["0.311", "1.9", 0.4],
-    ["-0.311", "1.9", -0.4],
-    ["1", "-1", 10],
-    ["11", "-1", 20],
-    ["1", "-2", 100],
-    ["-11", "-1", -20],
-    ["1", "-2", 100],
-    ["11", "-1.9", 20],
-    ["-11", "-1.9", -20],
-  ])("ROUNDUP(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test("ROUNDUP: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=ROUNDUP()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=ROUNDUP( , )" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(42, -1)" })).toBe(50);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP( , 42)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(42, )" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(42.42, TRUE)" })).toBe(42.5);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(42.42, FALSE)" })).toBe(43);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(TRUE, 10)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(FALSE, 10)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=ROUNDUP("" , "")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=ROUNDUP("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=ROUNDUP(" " , 0)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=ROUNDUP("42", -1)' })).toBe(50);
-    expect(evaluateCell("A1", { A1: '=ROUNDUP("42", "-1")' })).toBe(50);
-    expect(evaluateCell("A1", { A1: '=ROUNDUP("42", "")' })).toBe(42);
-
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "42", A3: "-1" })).toBe(50);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "", A3: "42" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "42", A3: "" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "42.42", A3: "TRUE" })).toBe(42.5);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "42.42", A3: "FALSE" })).toBe(43);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "TRUE", A3: "10" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: "FALSE", A3: "10" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: '"42"', A3: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=ROUNDUP(A2, A3)", A2: '="42"', A3: '="-1"' })).toBe(50);
-  });
-
-  //----------------------------------------------------------------------------
-  // SEC
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["=PI()/3", 2],
-    ["1", 1.850815718],
-    ["-2", -2.402997962],
-    ["3", -1.010108666],
-    ["-4", -1.529885656],
-    ["0", 1],
-  ])("SEC(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=SEC(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // SECH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", 0.648054274],
-    ["-1", 0.648054274],
-    ["0", 1],
-    ["=LN(2)", 0.8],
-    ["=-LN(3)", 0.6],
-  ])("SECH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=SECH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // SIN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 0],
-    ["=PI()", 0],
-    ["=PI()*2", 0],
-    ["=PI()/2", 1],
-    ["=PI()/6", 0.5],
-    ["=-PI()/2", -1],
-  ])("SIN(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  test("SIN: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=SIN()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=SIN(TRUE)" })).toBeCloseTo(0.841470984807897, 9);
-    expect(evaluateCell("A1", { A1: "=SIN(FALSE)" })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: '=SIN("")' })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: '=SIN(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SIN("0")' })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: "" })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: "0" })).toBeCloseTo(0, 9);
-
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: '"0"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: '=""' })).toBeCloseTo(0, 9);
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SIN(A2)", A2: '="0"' })).toBeCloseTo(0, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // SINH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["1", 1.175201194],
-    ["-2", -3.626860408],
-    ["0", 0],
-    ["=LN(2)", 0.75],
-    ["=-LN(4)", -1.875],
-  ])("SINH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=SINH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // SQRT
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 0],
-    ["4", 2],
-    ["9", 3],
-  ])("SQRT(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: a })).toBe(expected);
-  });
-
-  test.each([["-4"], ["-9"]])("SQRT(%s) - error: take 1 parameter(s), return an error ", (a) => {
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: a })).toBe("#ERROR"); // @compatibility: on google sheets, return #NUM!!
-  });
-
-  test("SQRT: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=SQRT()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=SQRT(TRUE)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=SQRT(FALSE)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=SQRT("")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=SQRT(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SQRT("49")' })).toBe(7);
-
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: "49" })).toBe(7);
-
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: '""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: '" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: '"0"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: '=""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SQRT(A2)", A2: '="49"' })).toBe(7);
-  });
-
-  //----------------------------------------------------------------------------
-  // SUM
-  //----------------------------------------------------------------------------
-
-  test("SUM: functional tests on simple arguments", () => {
-    expect(evaluateCell("A1", { A1: "=SUM()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=SUM(,)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(0)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(1, 2, 3, 1, 2)" })).toBe(9);
-    expect(evaluateCell("A1", { A1: "=SUM(1,  , 2,  , 3)" })).toBe(6);
-    expect(evaluateCell("A1", { A1: "=SUM(1.5, 1.4)" })).toBe(2.9);
-    expect(evaluateCell("A1", { A1: '=SUM("Jean Saigne", "Jean Tanrien")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM("")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(" ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM("2", "-2")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=SUM("2", "")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM("2", " ")' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: "=SUM(TRUE, FALSE)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: '=SUM(1, "1", TRUE)' })).toBe(3);
-    expect(evaluateCell("A1", { A1: '=SUM(1, "10/10/10")' })).toBe(40462);
-  });
-
-  test("SUM: functional tests on cell arguments", () => {
-    expect(evaluateCell("A1", { A1: "=SUM(A2)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2)", A2: " " })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2)", A2: "," })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2)", A2: "0" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "1", A3: "2" })).toBe(3);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3, A4)", A2: "1", A3: "", A4: "1" })).toBe(2);
-    expect(
-      evaluateCell("A1", { A1: "=SUM(A2, A3, A4)", A2: "1.5", A3: "-10", A4: "Jean Vier" })
-    ).toBe(-8.5);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: " ", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "", A3: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: " ", A3: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "  ", A3: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: " ", A3: '="  "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "42", A3: "42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "42", A3: '"42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "42", A3: "=42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "42", A3: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: '"42"', A3: '"42"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: '"42"', A3: "=42" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: '"42"', A3: '="42"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "=42", A3: "=42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: "=42", A3: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, A3)", A2: '="42"', A3: '="42"' })).toBe(0);
-  });
-
-  test("SUM: functional tests on simple and cell arguments", () => {
-    expect(evaluateCell("A1", { A1: "=SUM(A2,)", A2: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2,)", A2: " " })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2,)", A2: '=""' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=SUM(A2,)", A2: '=" "' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "")', A2: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "")', A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "")', A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "")', A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, " ")', A2: "" })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, " ")', A2: " " })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, " ")', A2: '=""' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(A2, " ")', A2: '=" "' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=SUM(42, "42")' })).toBe(84);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, 42)", A2: "10/10/10" })).toBe(40503);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, 42)", A2: "42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, 42)", A2: '"42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, 42)", A2: "=42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, 42)", A2: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "42")', A2: "42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "42")', A2: '"42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "42")', A2: "=42" })).toBe(84);
-    expect(evaluateCell("A1", { A1: '=SUM(A2, "42")', A2: '="42"' })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, TRUE)", A2: "1" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, TRUE)", A2: '"1"' })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, TRUE)", A2: "=1" })).toBe(2);
-    expect(evaluateCell("A1", { A1: "=SUM(A2, TRUE)", A2: '="1"' })).toBe(1);
-  });
-
-  test("SUM: functional tests on range arguments", () => {
-    const grid = {
-      A1: "=SUM(B2:D3,B4:D4,E2:E3,E4)",
-
-      A2: "=SUM(B2:E2)",
-      A3: "=SUM(B3:E3)",
-      A4: "=SUM(B4:E4)",
-      A5: "=SUM(B4:E2000)",
-
-      B1: "=SUM(B2:B4)",
-      C1: "=SUM(C2:C4)",
-      D1: "=SUM(D2:D4)",
-      E1: "=SUM(E2:E4)",
-
-      B2: "=3",
-      C2: "3",
-      D2: '"3"',
-      E2: '="3"',
-
-      B3: '=" "',
-      C3: "0",
-      D3: "Jean Bave",
-      E3: '"Jean Darme"',
-
-      B4: " ",
-      C4: '""',
-      D4: '=""',
-      E4: '" "',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.A1).toBe(6);
-    expect(gridResult.A2).toBe(6);
-    expect(gridResult.A3).toBe(0);
-    expect(gridResult.A4).toBe(0);
-    expect(gridResult.A5).toBe(0);
-    expect(gridResult.B1).toBe(3);
-    expect(gridResult.C1).toBe(3);
-    expect(gridResult.D1).toBe(0);
-    expect(gridResult.E1).toBe(0);
-  });
-
-  //----------------------------------------------------------------------------
-  // SUMIF
-  //----------------------------------------------------------------------------
-
-  test("COUNTUNIQUEIFS: functional tests on range", () => {
-    // prettier-ignore
-    const grid = {
-      A1:  "Coffee"    , B1:  "4"  ,
-      A2:  "Newspaper" , B2:  "1"  ,
-      A3:  "Taxi"      , B3:  "10" ,
-      A4:  "Golf"      , B4:  "26" ,
-      A5:  "Taxi"      , B5:  "8"  ,
-      A6:  "Coffee"    , B6:  "3.5",
-      A7:  "Gas"       , B7:  "46" ,
-      A8:  "Restaurant", B8:  "31" ,
-
-
-      A12: '=SUMIF(A1:A8, "Taxi", B1:B8)',
-      A13: '=SUMIF(B1:B8, ">=10", B1:B8)',
-      A14: '=SUMIF(B1:B8, ">=10")',
-      A15: '=SUMIF(A1:A8, "G*", B1:B8)',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.A12).toBe(18);
-    expect(gridResult.A13).toBe(113);
-    expect(gridResult.A14).toBe(113);
-    expect(gridResult.A15).toBe(72);
-  });
-
-  //----------------------------------------------------------------------------
-  // SUMIFS
-  //----------------------------------------------------------------------------
-
-  test("COUNTUNIQUEIFS: functional tests on range", () => {
-    // prettier-ignore
-    const grid = {
-      B1:  "4" , C1:  "14", D1:  "Yes",
-      B2:  "28", C2:  "30", D2:  "Yes",
-      B3:  "31", C3:  "47", D3:  "Yes",
-      B4:  "12", C4:  "0" , D4:  "Yes",
-      B5:  "31", C5:  "47", D5:  "Yes",
-      B6:  "13", C6:  "5" , D6:  "No" ,
-      B7:  "18", C7:  "43", D7:  "No" ,
-      B8:  "24", C8:  "7" , D8:  "Yes",
-      B9:  "44", C9:  "28", D9:  "No" ,
-      B10: "22", C10: "23", D10: "No" ,
-      B11: "9" , C11: "13", D11: "No" ,
-
-      A12: '=SUMIFS(B1:B11, B1:B11, ">20")',
-      A13: '=SUMIFS(B1:B11, B1:B11, ">20", C1:C11, "<30")',
-      A14: '=SUMIFS(B1:B11, D1:D11, "No")',
-    };
-
-    const gridResult = evaluateGrid(grid);
-    expect(gridResult.A12).toBe(180);
-    expect(gridResult.A13).toBe(90);
-    expect(gridResult.A14).toBe(106);
-  });
-
-  //----------------------------------------------------------------------------
-  // TAN
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["0", 0],
-    ["=PI()/4", 1],
-    ["1", 1.557407725],
-    ["2", -2.185039863],
-    ["-3", 0.142546543],
-    ["-4", -1.157821282],
-  ])("TAN(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=TAN(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // TANH
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["=LN(3)", 0.8],
-    ["=LN(2)", 0.6],
-    ["0", 0],
-    ["1", 0.761594156],
-    ["-2", -0.96402758],
-  ])("TANH(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=TANH(A2)", A2: a })).toBeCloseTo(expected, 9);
-  });
-
-  //----------------------------------------------------------------------------
-  // TRUNC
-  //----------------------------------------------------------------------------
-
-  test.each([
-    ["-1.6", -1],
-    ["-1.5", -1],
-    ["-1.4", -1],
-    ["0", 0],
-    ["1.4", 1],
-    ["1.5", 1],
-    ["1.6", 1],
-  ])("TRUNC(%s) - %s: take 1 parameter(s), return a number", (a, expected) => {
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: a })).toBe(expected);
-  });
-
-  test.each([
-    ["0.3", "2", 0.3],
-    ["0.34", "2", 0.34],
-    ["0.345", "2", 0.34],
-    ["-0.3", "2", -0.3],
-    ["-0.34", "2", -0.34],
-    ["-0.345", "2", -0.34],
-    ["0.345", "1.9", 0.3],
-    ["-0.345", "1.9", -0.3],
-    ["12345", "-1", 12340],
-    ["123456", "-1", 123450],
-    ["12345", "-2", 12300],
-    ["-123456", "-1", -123450],
-    ["-12345", "-2", -12300],
-    ["12345", "-1.9", 12340],
-    ["-12345", "-1.9", -12340],
-  ])("TRUNC(%s, %s) - %s: take 2 parameter(s), return a number", (a, b, expected) => {
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: a, A3: b })).toBe(expected);
-  });
-
-  test("TRUNC: special value testing", () => {
-    expect(evaluateCell("A1", { A1: "=TRUNC()" })).toBe("#BAD_EXPR"); // @compatibility: on google sheets, return #N/A
-    expect(evaluateCell("A1", { A1: "=TRUNC( , )" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=TRUNC(42, -1)" })).toBe(40);
-    expect(evaluateCell("A1", { A1: "=TRUNC( , 42)" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=TRUNC(42, )" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=TRUNC(42.42, TRUE)" })).toBe(42.4);
-    expect(evaluateCell("A1", { A1: "=TRUNC(42.42, FALSE)" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=TRUNC(TRUE, 10)" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=TRUNC(FALSE, 10)" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: '=TRUNC("" , "")' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=TRUNC("" , 12)' })).toBe(0);
-    expect(evaluateCell("A1", { A1: '=TRUNC(" " , 0)' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-    expect(evaluateCell("A1", { A1: '=TRUNC("42", -1)' })).toBe(40);
-    expect(evaluateCell("A1", { A1: '=TRUNC("42", "-1")' })).toBe(40);
-    expect(evaluateCell("A1", { A1: '=TRUNC("42", "")' })).toBe(42);
-
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "", A3: "" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "42", A3: "-1" })).toBe(40);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "", A3: "42" })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "42", A3: "" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "42.42", A3: "TRUE" })).toBe(42.4);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "42.42", A3: "FALSE" })).toBe(42);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "TRUE", A3: "10" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: "FALSE", A3: "10" })).toBe(0);
-
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: '"42"', A3: '"42"' })).toBe("#ERROR"); // @compatibility: on google sheets, return #VALUE!
-
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: '=""', A3: '="2"' })).toBe(0);
-    expect(evaluateCell("A1", { A1: "=TRUNC(A2, A3)", A2: '="42"', A3: '="-1"' })).toBe(40);
-  });
-});