@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/tests/functions/module_lookup_test.ts

@@ -1,541 +0,0 @@
-import { evaluateGrid } from "../helpers";
-
-describe("lookup", () => {
-  //----------------------------------------------------------------------------
-  // LOOKUP
-  //----------------------------------------------------------------------------
-
-  test("LOOKUP: functional tests on range", () => {
-    // prettier-ignore
-    const grid = {
-      A1: "1", B1: "res 01", C1: "res 11", D1: "res 21", E1: "res 31",
-      A2: "2", B2: "res 02", C2: "res 12", D2: "res 22", E2: "res 32", 
-      A3: "6", B3: "res 06", C3: "res 16", D3: "res 26", E3: "res 36", 
-      A4: "9", B4: "res 09", C4: "res 19", D4: "res 29", E4: "res 39",
-
-      A5: "=LOOKUP(6, A1:A4)", 
-      A6: "=LOOKUP(6, A1:B4)", 
-      A7: "=LOOKUP(6, A1:C4)",
-      A8: "=LOOKUP(6, A1:D4)",
-      A9: "=LOOKUP(6, A1:E4)",
-
-      A10: "=LOOKUP(6, A1:D4, E1:E4)", B10: "=LOOKUP(6, A1:C4, D1:E4)",
-      A11: "=LOOKUP(6, A1:A2, B3:B4)", B11: "=LOOKUP(6, A1:A2, B2:B4)", 
-      A12: "=LOOKUP(1, A1:A2, B1:C1)", B12: "=LOOKUP(2, A1:A2, B1:C1)", 
-
-      A13: "=LOOKUP(6, A1:A3, B2:B3)",
-      A14: "=LOOKUP(6, A1:A3, B3:C3)",
-
-      A15: "=LOOKUP(0, A1:B4)", 
-      A16: "=LOOKUP(10, A1:B4)"
-    };
-
-    const evaluatedGrid = evaluateGrid(grid);
-    expect(evaluatedGrid.A5).toBe(6);
-    expect(evaluatedGrid.A6).toBe("res 06");
-    expect(evaluatedGrid.A7).toBe("res 16");
-    expect(evaluatedGrid.A8).toBe("res 26");
-    expect(evaluatedGrid.A9).toBe(9);
-
-    expect(evaluatedGrid.A10).toBe("res 36");
-    expect(evaluatedGrid.B10).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(evaluatedGrid.A11).toBe("res 09");
-    expect(evaluatedGrid.B11).toBe("res 06");
-    expect(evaluatedGrid.A12).toBe("res 01");
-    expect(evaluatedGrid.B12).toBe("res 11");
-
-    expect(evaluatedGrid.A13).toBe("#ERROR"); // @compatibility: on googlesheets, return #NUM!
-    expect(evaluatedGrid.A14).toBe("#ERROR"); // @compatibility: on googlesheets, return #NUM!
-
-    expect(evaluatedGrid.A15).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(evaluatedGrid.A16).toBe("res 09");
-  });
-
-  test("LOOKUP: lookup dates", () => {
-    // prettier-ignore
-    const grid = {
-      A1: "01/03/2020", B1: "999",     C1: "15",     D1: "01/03/2020", E1: "01/04/2000",
-      A2: "missed1",    B2: "missed2", C2: "touché",
-
-      A4: "=LOOKUP(D1, A1:C1, A2:C2)",
-      A5: "=LOOKUP(E1, A1:C1, A2:C2)",
-    }
-    const evaluatedGrid = evaluateGrid(grid);
-    expect(evaluatedGrid.A4).toBe("touché");
-    expect(evaluatedGrid.A5).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-  });
-
-  //----------------------------------------------------------------------------
-  // MATCH
-  //----------------------------------------------------------------------------
-
-  // prettier-ignore
-  const rangeAscending = {
-    A1: "1", A2: "2", A3: "2", A4: "3",  A5: "5", A6: "6"
-  };
-
-  // prettier-ignore
-  const rangeUnsorted = {
-    A1: "1", A2: "5", A3: "3", A4: "3",  A5: "2", A6: "7"
-  };
-
-  // prettier-ignore
-  const rangeDescending = {
-    A1: "6", A2: "5", A3: "3", A4: "2",  A5: "2", A6: "1"
-  };
-
-  // prettier-ignore
-  const evAsAscending = {
-    B1: "=MATCH( 0, A1:A6, 1)", B2: "=MATCH( 1, A1:A6, 1)",
-    B3: "=MATCH( 2, A1:A6, 1)", B4: "=MATCH( 3, A1:A6, 1)",
-    B5: "=MATCH( 4, A1:A6, 1)", B6: "=MATCH( 5, A1:A6, 1)",
-    B7: "=MATCH( 6, A1:A6, 1)", B8: "=MATCH( 7, A1:A6, 1)"
-  };
-
-  // prettier-ignore
-  const evAsUnsorted = {
-    C1: "=MATCH( 0, A1:A6, 0)", C2: "=MATCH( 1, A1:A6, 0)",
-    C3: "=MATCH( 2, A1:A6, 0)", C4: "=MATCH( 3, A1:A6, 0)",
-    C5: "=MATCH( 4, A1:A6, 0)", C6: "=MATCH( 5, A1:A6, 0)",
-    C7: "=MATCH( 6, A1:A6, 0)", C8: "=MATCH( 7, A1:A6, 0)"
-  };
-
-  // prettier-ignore
-  const evAsDescending = {
-    D1: "=MATCH( 0, A1:A6, -1)", D2: "=MATCH( 1, A1:A6, -1)",
-    D3: "=MATCH( 2, A1:A6, -1)", D4: "=MATCH( 3, A1:A6, -1)",
-    D5: "=MATCH( 4, A1:A6, -1)", D6: "=MATCH( 5, A1:A6, -1)",
-    D7: "=MATCH( 6, A1:A6, -1)", D8: "=MATCH( 7, A1:A6, -1)"
-  };
-
-  test("MATCH: range evaluate sorted ascending", () => {
-    const ascendingAsAscending = { ...rangeAscending, ...evAsAscending };
-    const aAsA = evaluateGrid(ascendingAsAscending);
-
-    expect(aAsA.B1).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(aAsA.B2).toBe(1);
-    expect(aAsA.B3).toBe(3);
-    expect(aAsA.B4).toBe(4);
-    expect(aAsA.B5).toBe(4);
-    expect(aAsA.B6).toBe(5);
-    expect(aAsA.B7).toBe(6);
-    expect(aAsA.B8).toBe(6);
-
-    const ascendingAsUnsorted = { ...rangeAscending, ...evAsUnsorted };
-    const aAsU = evaluateGrid(ascendingAsUnsorted);
-
-    expect(aAsU.C1).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(aAsU.C2).toBe(1);
-    expect(aAsU.C3).toBe(2);
-    expect(aAsU.C4).toBe(4);
-    expect(aAsU.C5).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(aAsU.C6).toBe(5);
-    expect(aAsU.C7).toBe(6);
-    expect(aAsU.C8).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-
-    const ascendingAsDescending = { ...rangeAscending, ...evAsDescending };
-    const aAsD = evaluateGrid(ascendingAsDescending);
-
-    expect(aAsD.D1).toBe(6);
-    expect(aAsD.D2).toBe(6);
-    expect(aAsD.D3).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(aAsD.D4).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(aAsD.D5).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(aAsD.D6).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(aAsD.D7).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(aAsD.D8).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-  });
-
-  test("MATCH: range evaluate unsorted", () => {
-    const unsortedAsAscending = { ...rangeUnsorted, ...evAsAscending };
-    const uAsA = evaluateGrid(unsortedAsAscending);
-
-    expect(uAsA.B1).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(uAsA.B2).toBe(1);
-    expect(uAsA.B3).toBe(1);
-    expect(uAsA.B4).toBe(4); // @compatibility: on googlesheets, return 5
-    expect(uAsA.B5).toBe(4); // @compatibility: on googlesheets, return 5
-    expect(uAsA.B6).toBe(4); // @compatibility: on googlesheets, return 5
-    expect(uAsA.B7).toBe(4); // @compatibility: on googlesheets, return 5
-    expect(uAsA.B8).toBe(6);
-
-    const unsortedAsUnsorted = { ...rangeUnsorted, ...evAsUnsorted };
-    const uAsU = evaluateGrid(unsortedAsUnsorted);
-
-    expect(uAsU.C1).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(uAsU.C2).toBe(1);
-    expect(uAsU.C3).toBe(5);
-    expect(uAsU.C4).toBe(3);
-    expect(uAsU.C5).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(uAsU.C6).toBe(2);
-    expect(uAsU.C7).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(uAsU.C8).toBe(6);
-
-    const unsortedAsDescending = { ...rangeUnsorted, ...evAsDescending };
-    const uAsD = evaluateGrid(unsortedAsDescending);
-
-    expect(uAsD.D1).toBe(6);
-    expect(uAsD.D2).toBe(6);
-    expect(uAsD.D3).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(uAsD.D4).toBe("#ERROR"); // @compatibility: on googlesheets, return 3
-    expect(uAsD.D5).toBe("#ERROR"); // @compatibility: on googlesheets, return 2
-    expect(uAsD.D6).toBe("#ERROR"); // @compatibility: on googlesheets, return 2
-    expect(uAsD.D7).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(uAsD.D8).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-  });
-
-  test("MATCH: range evaluate sorted descending", () => {
-    const descendingAsAscending = { ...rangeDescending, ...evAsAscending };
-    const dAsA = evaluateGrid(descendingAsAscending);
-
-    expect(dAsA.B1).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(dAsA.B2).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(dAsA.B3).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(dAsA.B4).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(dAsA.B5).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(dAsA.B6).toBe("#ERROR"); // @compatibility: on googlesheets, return 6
-    expect(dAsA.B7).toBe(6);
-    expect(dAsA.B8).toBe(6);
-
-    const descendingAsUnsorted = { ...rangeDescending, ...evAsUnsorted };
-    const dAsU = evaluateGrid(descendingAsUnsorted);
-
-    expect(dAsU.C1).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(dAsU.C2).toBe(6);
-    expect(dAsU.C3).toBe(4);
-    expect(dAsU.C4).toBe(3);
-    expect(dAsU.C5).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(dAsU.C6).toBe(2);
-    expect(dAsU.C7).toBe(1);
-    expect(dAsU.C8).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-
-    const descendingAsDescending = { ...rangeDescending, ...evAsDescending };
-    const dAsD = evaluateGrid(descendingAsDescending);
-
-    expect(dAsD.D1).toBe(6);
-    expect(dAsD.D2).toBe(6);
-    expect(dAsD.D3).toBe(4);
-    expect(dAsD.D4).toBe(3);
-    expect(dAsD.D5).toBe(2);
-    expect(dAsD.D6).toBe(2);
-    expect(dAsD.D7).toBe(1);
-    expect(dAsD.D8).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-  });
-
-  test("MATCH: grid of STRING ascending", () => {
-    // prettier-ignore
-    const ascendingStringEvAsAscending = {
-      A1: '="1"', A2: '="10"', A3: '="100"', A4: '="2"',  A5: '="2"',
-      B1: '=MATCH( "1",   A1:A5, 1)',
-      B2: '=MATCH( "2",   A1:A5, 1)',
-      B3: '=MATCH( "5",   A1:A5, 1)',
-      B4: '=MATCH( "10",  A1:A5, 1)',
-      B5: '=MATCH( "100", A1:A5, 1)',
-    };
-    const ascendingString = evaluateGrid(ascendingStringEvAsAscending);
-
-    expect(ascendingString.B1).toBe(1);
-    expect(ascendingString.B2).toBe(5);
-    expect(ascendingString.B3).toBe(5);
-    expect(ascendingString.B4).toBe(2);
-    expect(ascendingString.B5).toBe(3);
-  });
-
-  test("MATCH: grid of STRING unsorted", () => {
-    // prettier-ignore
-    const unsortedStringEvAsUnsorted = {
-      A1: '="1"', A2: '="2"', A3: '="2"', A4: '="10"',  A5: '="100"',
-      C1: '=MATCH( "1",   A1:A5, 0)',
-      C2: '=MATCH( "2",   A1:A5, 0)',
-      C3: '=MATCH( "5",   A1:A5, 0)',
-      C4: '=MATCH( "10",  A1:A5, 0)',
-      C5: '=MATCH( "100", A1:A5, 0)',
-    };
-    const unsortedString = evaluateGrid(unsortedStringEvAsUnsorted);
-
-    expect(unsortedString.C1).toBe(1);
-    expect(unsortedString.C2).toBe(2);
-    expect(unsortedString.C3).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(unsortedString.C4).toBe(4);
-    expect(unsortedString.C5).toBe(5);
-  });
-
-  test("MATCH: grid of STRING descending", () => {
-    // prettier-ignore
-    const descendingStringEvAsDescending = {
-      A1: '="2"', A2: '="2"', A3: '="100"', A4: '="10"',  A5: '="1"',
-      D1: '=MATCH( "1",   A1:A5, -1)',
-      D2: '=MATCH( "2",   A1:A5, -1)',
-      D3: '=MATCH( "5",   A1:A5, -1)',
-      D4: '=MATCH( "10",  A1:A5, -1)',
-      D5: '=MATCH( "100", A1:A5, -1)',
-    }
-    const descendingString = evaluateGrid(descendingStringEvAsDescending);
-
-    expect(descendingString.D1).toBe(5);
-    expect(descendingString.D2).toBe(1);
-    expect(descendingString.D3).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(descendingString.D4).toBe(4);
-    expect(descendingString.D5).toBe(3);
-  });
-
-  test("MATCH: match dates", () => {
-    // prettier-ignore
-    const grid = {
-      A1: "01/03/2020", B1: "999",    C1: "15",     D1: "01/03/2020", E1: "01/04/2000",
-
-      A4: "=MATCH(D1, A1:C1, 0)",
-      A5: "=MATCH(D1, A1:C1, 1)",
-      A6: "=MATCH(E1, A1:C1, 0)",
-      A7: "=MATCH(E1, A1:C1, 1)",
-    }
-    const evaluatedGrid = evaluateGrid(grid);
-    expect(evaluatedGrid.A4).toBe(1);
-    expect(evaluatedGrid.A5).toBe(3);
-    expect(evaluatedGrid.A6).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(evaluatedGrid.A7).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-  });
-
-  //----------------------------------------------------------------------------
-  // VLOOKUP
-  //----------------------------------------------------------------------------
-
-  describe("VLOOKUP formula", () => {
-    describe("sorted values with different type", () => {
-      test("with undefined values", () => {
-        // prettier-ignore
-        const rangesGrid = {
-          A1: "42",      B1: "42",      C1: undefined, D1: undefined, E1: undefined, Z1: "1",
-          A2: undefined, B2: undefined, C2: undefined, D2: undefined, E2: undefined, Z2: "2",
-          A3: undefined, B3: "42",      C3: undefined, D3: "42",      E3: undefined, Z3: "3",
-          A4: undefined, B4: undefined, C4: undefined, D4: undefined, E4: undefined, Z4: "4",
-          A5: undefined, B5: undefined, C5: "42",      D5: "42",      E5: undefined, Z5: "5",
-        };
-        const grid = evaluateGrid({
-          ...rangesGrid,
-          A9: "=VLOOKUP(42, A1:Z5, 26, TRUE)",
-          B9: "=VLOOKUP(42, B1:Z5, 25, TRUE)",
-          C9: "=VLOOKUP(42, C1:Z5, 24, TRUE)",
-          D9: "=VLOOKUP(42, D1:Z5, 23, TRUE)",
-          E9: "=VLOOKUP(42, E1:Z5, 22, TRUE)",
-        });
-        expect(grid.A9).toBe(1);
-        expect(grid.B9).toBe(3);
-        expect(grid.C9).toBe(5);
-        expect(grid.D9).toBe(5);
-        expect(grid.E9).toBe("#ERROR");
-      });
-
-      test("lookup string with string and number values", () => {
-        // prettier-ignore
-        const rangesGrid  = {
-          A1: "coucou", B1: "coucou", C1: "42",    D1: "42",     E1: "42", F1: "42",    Z1: "1",
-          A2: "42",     B2: "42",     C2: "42",    D2: "42",     E2: "42", F2: "42",    Z2: "2",
-          A3: "42",     B3: "coucou", C3: "42",    D3: "coucou", E3: "42", F3: `="42"`, Z3: "3",
-          A4: "42",     B4: "42",     C4: "42",    D4: "42",     E4: "42", F4: "42",    Z4: "4",
-          A5: "42",     B5: "42",     C5:"coucou", D5: "coucou", E5: "42", F5: "42",    Z5: "5",
-        };
-
-        const grid = evaluateGrid({
-          ...rangesGrid,
-          A9: '=VLOOKUP("coucou", A1:Z5, 26, TRUE)',
-          B9: '=VLOOKUP("coucou", B1:Z5, 25, TRUE)',
-          C9: '=VLOOKUP("coucou", C1:Z5, 24, TRUE)',
-          D9: '=VLOOKUP("coucou", D1:Z5, 23, TRUE)',
-          E9: '=VLOOKUP("coucou", E1:Z5, 22, TRUE)',
-          F9: '=VLOOKUP("42", F1:Z5, 21, TRUE)',
-        });
-        expect(grid.A9).toBe(1);
-        expect(grid.B9).toBe(3);
-        expect(grid.C9).toBe(5);
-        expect(grid.D9).toBe(5);
-        expect(grid.E9).toBe("#ERROR");
-        expect(grid.F9).toBe(3);
-      });
-
-      test("lookup number with number and string values", () => {
-        // prettier-ignore
-        const rangesGrid = {
-          A1: "666", B1: "666", C1: "abc", D1: "abc", E1: "abc", Z1: "1",
-          A2: "abc", B2: "abc", C2: "abc", D2: "abc", E2: "abc", Z2: "2",
-          A3: "abc", B3: "666", C3: "abc", D3: "666", E3: "abc", Z3: "3",
-          A4: "abc", B4: "abc", C4: "abc", D4: "abc", E4: "abc", Z4: "4",
-          A5: "abc", B5: "abc", C5: "666", D5: "666", E5: "abc", Z5: "5",
-        };
-        const grid = evaluateGrid({
-          ...rangesGrid,
-          A9: "=VLOOKUP(666, A1:Z5, 26, TRUE)",
-          B9: "=VLOOKUP(666, B1:Z5, 25, TRUE)",
-          C9: "=VLOOKUP(666, C1:Z5, 24, TRUE)",
-          D9: "=VLOOKUP(666, D1:Z5, 23, TRUE)",
-          E9: "=VLOOKUP(666, E1:Z5, 22, TRUE)",
-        });
-        expect(grid.A9).toBe(1);
-        expect(grid.B9).toBe(3);
-        expect(grid.C9).toBe(5);
-        expect(grid.D9).toBe(5);
-        expect(grid.E9).toBe("#ERROR");
-      });
-    });
-
-    // prettier-ignore
-    const commonGrid = {
-      B1: "B1", C1: "C1", D1: "D1", E1: "E1",
-      B2: "B2", C2: "C2", D2: "D2", E2: "E2",
-      B3: "B3", C3: "C3", D3: "D3", E3: "E3",
-      B4: "B4", C4: "C4", D4: "D4", E4: "E4",
-      B5: "B5", C5: "C5", D5: "D5", E5: "E5",
-      B6: "B6", C6: "C6", D6: "D6", E6: "E6",
-    };
-    test("if index not between 1 and the number of columns --> return #ERROR", () => {
-      const grid = evaluateGrid({
-        ...commonGrid,
-        Z1: '=VLOOKUP( "B4", B1:E5, 0)',
-        Z2: '=VLOOKUP( "B4", B1:E5, 5)',
-      });
-      expect(grid.Z1).toBe("#ERROR"); // @compatibility: on googlesheets, return #VALUE!
-      expect(grid.Z2).toBe("#ERROR"); // @compatibility: on googlesheets, return #VALUE!
-    });
-    test("if float index --> index rounded down", () => {
-      const grid = evaluateGrid({
-        ...commonGrid,
-        Z1: '=VLOOKUP( "B4", B1:E5, 2.9)',
-        Z2: '=VLOOKUP( "B4", B1:E5, 4.3)',
-      });
-      expect(grid.Z1).toBe("C4");
-      expect(grid.Z2).toBe("E4");
-    });
-    // prettier-ignore
-    const numSorted = {
-      A1: "1", A2: "2", A3: "=A2", A4: "3", A5: "5", A6: "=A5",
-      X1: "4", X2: "6", X3: "-3", X4: "0" // other testing values
-    };
-    // prettier-ignore
-    const numUnsorted = {
-      A1: "1", A2: "2", A3: "5", A4: "3", A5: "=A2", A6: "=A3",
-      X1: "4", X2: "6" // other testing values
-    };
-    // prettier-ignore
-    const stringSorted = {
-      A1: 'ab', A2: 'abc',  A3: "=A2", A4: 'abcd', A5: 'ba', A6: "=A5",
-      X1: "abcde", X2: "bac", X3: "a", X4: "aa" // other testing values
-    };
-    // prettier-ignore
-    const stringUnsorted = {
-      A1: 'ab', A2: 'abc', A3: 'ba', A4: 'abcd', A5: '=A2', A6: '=A3',
-      X1: "abcde", X2: "bac" // other testing values
-    };
-    describe.each([
-      ["numerical values", numSorted, numUnsorted],
-      ["string values", stringSorted, stringUnsorted],
-    ])("search on %s", (typeValues, colSorted, colUnsorted) => {
-      const gridSorted = { ...colSorted, ...commonGrid };
-      const gridUnsorted = { ...colUnsorted, ...commonGrid };
-      describe("if values are evaluated as sorted", () => {
-        test("if find a value --> return the match value (normal behavior)", () => {
-          const grid = evaluateGrid({
-            ...gridSorted,
-            Z1: "=VLOOKUP( A4, A1:E6, 3, TRUE )",
-            Z2: "=VLOOKUP( A1, A1:E6, 4, TRUE )",
-          });
-          expect(grid.Z1).toBe("C4");
-          expect(grid.Z2).toBe("D1");
-        });
-        test("if find multiple values --> return match to last value", () => {
-          const grid = evaluateGrid({
-            ...gridSorted,
-            Z1: "=VLOOKUP( A2, A1:E6, 3, TRUE )",
-            Z2: "=VLOOKUP( A5, A1:E6, 3, TRUE )",
-          });
-          expect(grid.Z1).toBe("C3");
-          expect(grid.Z2).toBe("C6");
-        });
-        test("if not find value --> return match to the nearest value (less than the search key)", () => {
-          const grid = evaluateGrid({
-            ...gridSorted,
-            Z1: "=VLOOKUP( X1, A1:E6, 3, TRUE )",
-            Z2: "=VLOOKUP( X2, A1:E6, 3, TRUE )",
-            Z3: "=VLOOKUP( X2, A10:A16, 1, TRUE )",
-          });
-          expect(grid.Z1).toBe("C4");
-          expect(grid.Z2).toBe("C6");
-          expect(grid.Z3).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-        });
-
-        test("if all values in the search column are greater than the search key --> return #ERROR ", () => {
-          const grid = evaluateGrid({
-            ...gridSorted,
-            Z1: "=VLOOKUP( X3, A1:E6, 3, TRUE )",
-            Z2: "=VLOOKUP( X4, A1:E6, 3, TRUE )",
-          });
-          expect(grid.Z1).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-          expect(grid.Z2).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-        });
-      });
-      describe("if values are evaluated as unsorted", () => {
-        test("if find a value --> return the match value (normal behavior)", () => {
-          const gridS = evaluateGrid({
-            ...gridSorted,
-            Z1: "=VLOOKUP( A4, A1:E6, 3, FALSE )",
-            Z2: "=VLOOKUP( A1, A1:E6, 4, FALSE )",
-          });
-          expect(gridS.Z1).toBe("C4");
-          expect(gridS.Z2).toBe("D1");
-          const gridU = evaluateGrid({
-            ...gridUnsorted,
-            Z1: "=VLOOKUP( A4, A1:E6, 3, FALSE )",
-            Z2: "=VLOOKUP( A1, A1:E6, 4, FALSE )",
-          });
-          expect(gridU.Z1).toBe("C4");
-          expect(gridU.Z2).toBe("D1");
-        });
-        test("if find multiple values --> return match to first value", () => {
-          const gridS = evaluateGrid({
-            ...gridSorted,
-            Z1: "=VLOOKUP( A2, A1:E6, 3, FALSE )",
-            Z2: "=VLOOKUP( A5, A1:E6, 3, FALSE )",
-          });
-          expect(gridS.Z1).toBe("C2");
-          expect(gridS.Z2).toBe("C5");
-          const gridU = evaluateGrid({
-            ...gridUnsorted,
-            Z1: "=VLOOKUP( A2, A1:E6, 3, FALSE )",
-            Z2: "=VLOOKUP( A3, A1:E6, 3, FALSE )",
-          });
-          expect(gridU.Z1).toBe("C2");
-          expect(gridU.Z2).toBe("C3");
-        });
-        test("if not find value --> #ERROR is returned ", () => {
-          const formulas = {
-            Z1: "=VLOOKUP( X1, A1:E6, 3, FALSE )",
-            Z2: "=VLOOKUP( X2, A1:E6, 3, FALSE )",
-          };
-          const gridS = evaluateGrid({ ...gridSorted, ...formulas });
-          expect(gridS.Z1).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-          expect(gridS.Z2).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-          const gridU = evaluateGrid({ ...gridUnsorted, ...formulas });
-          expect(gridU.Z1).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-          expect(gridU.Z2).toBe("#ERROR"); // @compatibility: on google sheets return #N/A
-        });
-      });
-    });
-  });
-
-  test("VLOOKUP: lookup dates", () => {
-    // prettier-ignore
-    const grid = {
-      A1: "01/03/2020", B1: "999",     C1: "15",     D1: "01/03/2020", E1: "01/04/2000",
-      A2: "touché",     B2: "missed1", C2: "missed2",
-
-      A4: "=VLOOKUP(D1, A1:C2, 2, 0)",
-      A5: "=VLOOKUP(D1, A1:C2, 2, 1)",
-      A6: "=VLOOKUP(E1, A1:C2, 2, 0)",
-      A7: "=VLOOKUP(E1, A1:C2, 2, 1)",
-    }
-    const evaluatedGrid = evaluateGrid(grid);
-    expect(evaluatedGrid.A4).toBe(999);
-    expect(evaluatedGrid.A5).toBe(999);
-    expect(evaluatedGrid.A6).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-    expect(evaluatedGrid.A7).toBe("#ERROR"); // @compatibility: on googlesheets, return #N/A
-  });
-});