@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/tests/formulas/composer_tokenizer_test.ts

@@ -1,137 +0,0 @@
-import { composerTokenize } from "../../src/formulas/composer_tokenizer";
-
-describe("composerTokenizer", () => {
-  test("only range", () => {
-    expect(composerTokenize("=A1:A2")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 6, length: 5, type: "SYMBOL", value: "A1:A2" },
-    ]);
-  });
-  test("operation and no range", () => {
-    expect(composerTokenize("=A3+A1")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 3, length: 2, type: "SYMBOL", value: "A3" },
-      { start: 3, end: 4, length: 1, type: "OPERATOR", value: "+" },
-      { start: 4, end: 6, length: 2, type: "SYMBOL", value: "A1" },
-    ]);
-  });
-  test("operation and range", () => {
-    expect(composerTokenize("=A3+A1:A2")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 3, length: 2, type: "SYMBOL", value: "A3" },
-      { start: 3, end: 4, length: 1, type: "OPERATOR", value: "+" },
-      { start: 4, end: 9, length: 5, type: "SYMBOL", value: "A1:A2" },
-    ]);
-  });
-  test("operation and range with spaces", () => {
-    expect(composerTokenize("=A3+  A1 : A2   ")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 3, length: 2, type: "SYMBOL", value: "A3" },
-      { start: 3, end: 4, length: 1, type: "OPERATOR", value: "+" },
-      { start: 4, end: 16, length: 12, type: "SYMBOL", value: "  A1 : A2   " },
-    ]);
-  });
-
-  test("range with spaces then operation", () => {
-    expect(composerTokenize("=  A1 : A2   +a3")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 13, length: 12, type: "SYMBOL", value: "  A1 : A2   " },
-      { start: 13, end: 14, length: 1, type: "OPERATOR", value: "+" },
-      { start: 14, end: 16, length: 2, type: "SYMBOL", value: "a3" },
-    ]);
-  }); //"= SUM ( C4 : C5 )"
-
-  test("= SUM ( C4 : C5 )", () => {
-    expect(composerTokenize("= SUM ( C4 : C5 )")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 2, length: 1, type: "SPACE", value: " " },
-      { start: 2, end: 5, length: 3, type: "FUNCTION", value: "SUM" },
-      { start: 5, end: 6, length: 1, type: "SPACE", value: " " },
-      { start: 6, end: 7, length: 1, type: "LEFT_PAREN", value: "(", parenIndex: 1 },
-      { start: 7, end: 16, length: 9, type: "SYMBOL", value: " C4 : C5 " },
-      { start: 16, end: 17, length: 1, type: "RIGHT_PAREN", value: ")", parenIndex: 1 },
-    ]);
-  });
-});
-
-describe("composerTokenizer base tests", () => {
-  test("simple token", () => {
-    expect(composerTokenize("1")).toEqual([
-      { start: 0, end: 1, length: 1, type: "NUMBER", value: "1" },
-    ]);
-  });
-  test("formula token", () => {
-    expect(composerTokenize("=1")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 2, length: 1, type: "NUMBER", value: "1" },
-    ]);
-  });
-  test("longer operators >=", () => {
-    expect(composerTokenize("= >= <= <")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 2, length: 1, type: "SPACE", value: " " },
-      { start: 2, end: 4, length: 2, type: "OPERATOR", value: ">=" },
-      { start: 4, end: 5, length: 1, type: "SPACE", value: " " },
-      { start: 5, end: 7, length: 2, type: "OPERATOR", value: "<=" },
-      { start: 7, end: 8, length: 1, type: "SPACE", value: " " },
-      { start: 8, end: 9, length: 1, type: "OPERATOR", value: "<" },
-    ]);
-  });
-
-  test("debug formula token", () => {
-    expect(composerTokenize("=?1")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 2, length: 1, type: "DEBUGGER", value: "?" },
-      { start: 2, end: 3, length: 1, type: "NUMBER", value: "1" },
-    ]);
-  });
-  test("String", () => {
-    expect(composerTokenize('"hello"')).toEqual([
-      { start: 0, end: 7, length: 7, type: "STRING", value: '"hello"' },
-    ]);
-    //expect(() => composerTokenize("'hello'")).toThrowError("kikou");
-    expect(composerTokenize("'hello'")).toEqual([
-      { start: 0, end: 7, length: 7, type: "SYMBOL", value: "'hello'" },
-    ]);
-    expect(composerTokenize('"he\\"l\\"lo"')).toEqual([
-      { start: 0, end: 11, length: 11, type: "STRING", value: '"he\\"l\\"lo"' },
-    ]);
-    expect(composerTokenize("\"hel'l'o\"")).toEqual([
-      { start: 0, end: 9, length: 9, type: "STRING", value: "\"hel'l'o\"" },
-    ]);
-    expect(composerTokenize('"hello""test"')).toEqual([
-      { start: 0, end: 7, length: 7, type: "STRING", value: '"hello"' },
-      { start: 7, end: 13, length: 6, type: "STRING", value: '"test"' },
-    ]);
-  });
-
-  test("Function token", () => {
-    expect(composerTokenize("SUM")).toEqual([
-      { start: 0, end: 3, length: 3, type: "FUNCTION", value: "SUM" },
-    ]);
-    expect(composerTokenize("RAND")).toEqual([
-      { start: 0, end: 4, length: 4, type: "FUNCTION", value: "RAND" },
-    ]);
-  });
-  test("Boolean", () => {
-    expect(composerTokenize("true")).toEqual([
-      { start: 0, end: 4, length: 4, type: "SYMBOL", value: "true" },
-    ]);
-    expect(composerTokenize("false")).toEqual([
-      { start: 0, end: 5, length: 5, type: "SYMBOL", value: "false" },
-    ]);
-    expect(composerTokenize("=AND(true,false)")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 4, length: 3, type: "FUNCTION", value: "AND" },
-      { start: 4, end: 5, length: 1, type: "LEFT_PAREN", value: "(", parenIndex: 1 },
-      { start: 5, end: 9, length: 4, type: "SYMBOL", value: "true" },
-      { start: 9, end: 10, length: 1, type: "COMMA", value: "," },
-      { start: 10, end: 15, length: 5, type: "SYMBOL", value: "false" },
-      { start: 15, end: 16, length: 1, type: "RIGHT_PAREN", parenIndex: 1, value: ")" },
-    ]);
-    expect(composerTokenize("=trueee")).toEqual([
-      { start: 0, end: 1, length: 1, type: "OPERATOR", value: "=" },
-      { start: 1, end: 7, length: 6, type: "SYMBOL", value: "trueee" },
-    ]);
-  });
-});

package/tests/formulas/expressions_test.ts

@@ -1,57 +0,0 @@
-import { evaluateCell } from "../helpers";
-
-/**
- * Tests in this file are supposed to test mostly the compiler/functions parts,
- * not the semantic of the recursive evaluation of formulas.
- */
-
-describe("expression evaluation", () => {
-  test("arithmetic expressions", () => {
-    expect(evaluateCell("A1", { A1: "=1" })).toBe(1);
-    expect(evaluateCell("A1", { A1: "=2 + 3 * 4" })).toBe(14);
-  });
-
-  test("comparisons", () => {
-    // eq
-    expect(evaluateCell("A1", { A1: "=2 = 1" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=2 = 2" })).toBe(true);
-
-    // gt
-    expect(evaluateCell("A1", { A1: "=2 > 1" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=1 > 2" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=1 > 1" })).toBe(false);
-    // gte
-    expect(evaluateCell("A1", { A1: "=1 >= 1" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=1 >= 0" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=-1 >= 3" })).toBe(false);
-    // lt
-    expect(evaluateCell("A1", { A1: "=1 < 2" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=2 < 2" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=3 < 2" })).toBe(false);
-    // lte
-    expect(evaluateCell("A1", { A1: "=1 <= 2" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=2 <= 2" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=3 <= 2" })).toBe(false);
-  });
-
-  test("priority of operations", () => {
-    expect(evaluateCell("A1", { A1: "=4 > 1 + 2" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=4 < 1 + 2" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=4 >= 1 + 2" })).toBe(true);
-    expect(evaluateCell("A1", { A1: "=4 <= 1 + 2" })).toBe(false);
-    expect(evaluateCell("A1", { A1: "=2 = 1 + 1" })).toBe(true);
-
-    expect(evaluateCell("A1", { A1: '="4" > 1 & 2' })).toBe(true);
-    expect(evaluateCell("A1", { A1: '="4" < 1 & 2' })).toBe(false);
-    expect(evaluateCell("A1", { A1: '="4" >= 1 & 2' })).toBe(true);
-    expect(evaluateCell("A1", { A1: '="4" <= 1 & 2' })).toBe(false);
-    expect(evaluateCell("A1", { A1: '="12" = 1 & 2' })).toBe(true);
-  });
-
-  test("miscellaneous formulas", () => {
-    const r1 = evaluateCell("A2", { A2: "=SUM(A1,B1)", A1: "1", B1: "2" });
-    expect(r1).toBe(3);
-    const r2 = evaluateCell("A2", { A2: "=SUM(A1:B1)", A1: "1", B1: "2" });
-    expect(r2).toBe(3);
-  });
-});

package/tests/formulas/formulas_test.ts

@@ -1,80 +0,0 @@
-import { Model } from "../../src";
-import "../canvas.mock";
-
-describe("applyOffset", () => {
-  test("simple changes", () => {
-    const model = new Model({
-      sheets: [
-        {
-          colNumber: 10,
-          rowNumber: 10,
-        },
-      ],
-    });
-    expect(model.getters.applyOffset("=A1", 1, 1)).toEqual("=B2");
-    expect(model.getters.applyOffset("=A1 + B3", 1, 1)).toEqual("=B2 + C4");
-  });
-
-  test("can handle negative offsets", () => {
-    const model = new Model();
-    expect(model.getters.applyOffset("=B2", 0, -1)).toEqual("=B1");
-    expect(model.getters.applyOffset("=B2", -1, 0)).toEqual("=A2");
-    expect(model.getters.applyOffset("=B2", -1, -1)).toEqual("=A1");
-    expect(model.getters.applyOffset("=B2", 0, -4)).toEqual("=#REF");
-    expect(model.getters.applyOffset("=B2", -4, 0)).toEqual("=#REF");
-  });
-
-  test("can handle offsets outside the sheet", () => {
-    const model = new Model({
-      sheets: [
-        {
-          colNumber: 10,
-          rowNumber: 10,
-        },
-      ],
-    });
-    expect(model.getters.applyOffset("=B2", 0, -4)).toEqual("=#REF");
-    expect(model.getters.applyOffset("=B10", 0, 2)).toEqual("=B12");
-    expect(model.getters.applyOffset("=J1", 2, 0)).toEqual("=L1");
-  });
-
-  test("can handle other formulas", () => {
-    const model = new Model({
-      sheets: [
-        {
-          colNumber: 10,
-          rowNumber: 10,
-        },
-      ],
-    });
-    expect(model.getters.applyOffset("=AND(true, B2)", 0, 1)).toEqual("=AND(true, B3)");
-  });
-
-  test("can handle cross-sheet formulas", () => {
-    const model = new Model({
-      sheets: [
-        {
-          colNumber: 10,
-          rowNumber: 10,
-        },
-        {
-          name: "Sheet2",
-          colNumber: 5,
-          rowNumber: 5,
-        },
-      ],
-    });
-    expect(model.getters.applyOffset("=Sheet2!B2", 0, 1)).toEqual("=Sheet2!B3");
-    expect(model.getters.applyOffset("='Sheet2'!B2", 0, 1)).toEqual("=Sheet2!B3");
-    expect(model.getters.applyOffset("=Sheet2!B2", 0, -2)).toEqual("=#REF");
-    expect(model.getters.applyOffset("=Sheet2!B2", -2, 0)).toEqual("=#REF");
-    expect(model.getters.applyOffset("=Sheet2!B2", 1, 1)).toEqual("=Sheet2!C3");
-    expect(model.getters.applyOffset("=Sheet2!B2", 1, 10)).toEqual("=Sheet2!C12");
-  });
-
-  test("can handle sheet reference with names", () => {
-    const model = new Model();
-    model.dispatch("CREATE_SHEET", { id: "42", name: "Sheet 2" });
-    expect(model.getters.applyOffset("='Sheet 2'!B2", 0, 1)).toEqual("='Sheet 2'!B3");
-  });
-});

package/tests/formulas/normalize_test.ts

@@ -1,82 +0,0 @@
-import { normalize } from "../../src/formulas";
-
-test("basic formula with only boolean arguments should be unchanged", () => {
-  expect(normalize("=Sum( TRUE , FALSE) + TRUE - ( FALSE * TRUE)")).toEqual({
-    text: "=Sum( TRUE , FALSE) + TRUE - ( FALSE * TRUE)",
-    dependencies: [],
-  });
-});
-
-test("replace references with different syntax", () => {
-  expect(normalize("=A1")).toEqual({
-    text: "=|0|",
-    dependencies: ["A1"],
-  });
-  expect(normalize("=$A$1")).toEqual({
-    text: "=|0|",
-    dependencies: ["$A$1"],
-  });
-  expect(normalize("=Sheet1!A1")).toEqual({
-    text: "=|0|",
-    dependencies: ["Sheet1!A1"],
-  });
-  expect(normalize("='Sheet1'!A1")).toEqual({
-    text: "=|0|",
-    dependencies: ["'Sheet1'!A1"],
-  });
-  expect(normalize("='Sheet1'!A$1")).toEqual({
-    text: "=|0|",
-    dependencies: ["'Sheet1'!A$1"],
-  });
-  expect(normalize("=A1:b2")).toEqual({
-    text: "=|0|",
-    dependencies: ["A1:b2"],
-  });
-  expect(normalize("=$A$1:$b$2")).toEqual({
-    text: "=|0|",
-    dependencies: ["$A$1:$b$2"],
-  });
-  expect(normalize("=Sheet1!A1:b2")).toEqual({
-    text: "=|0|",
-    dependencies: ["Sheet1!A1:b2"],
-  });
-  expect(normalize("='SHEET 1'!A1:b2")).toEqual({
-    text: "=|0|",
-    dependencies: ["'SHEET 1'!A1:b2"],
-  });
-  expect(normalize("='Sheet1'!A$1:$B2")).toEqual({
-    text: "=|0|",
-    dependencies: ["'Sheet1'!A$1:$B2"],
-  });
-});
-test("replace multiple references", () => {
-  expect(normalize("=sum(a1:a3, a1:a3) + a1")).toEqual({
-    text: "=sum(|0|,|0|) + |1|",
-    dependencies: ["a1:a3", "a1"],
-  });
-});
-test("replace numbers in functions, numbers are parsed", () => {
-  expect(normalize("=sum(1, 5%) + 7")).toEqual({
-    text: "=sum(|N0|, |N1|) + |N2|",
-    dependencies: [1, 0.05, 7],
-  });
-});
-test("replace strings in functions", () => {
-  expect(normalize('=CONCATENATE("a", "5", "b")')).toEqual({
-    text: "=CONCATENATE(|S0|, |S1|, |S2|)",
-    dependencies: ["a", "5", "b"],
-  });
-});
-test("replace multiple on function", () => {
-  expect(normalize('=CONCATENATE(A1:A3, 5, "b")')).toEqual({
-    text: "=CONCATENATE(|0|, |N1|, |S2|)",
-    dependencies: ["A1:A3", 5, "b"],
-  });
-});
-test("do not replace normalized dependencies inside strings", () => {
-  const formula = '=concat("|1|","|S0|","|N2|")';
-  expect(normalize(formula)).toEqual({
-    text: "=concat(|S0|,|S1|,|S2|)",
-    dependencies: ["|1|", "|S0|", "|N2|"],
-  });
-});

package/tests/formulas/parser_test.ts

@@ -1,224 +0,0 @@
-import { astToFormula, normalize } from "../../src";
-import { parse } from "../../src/formulas";
-
-describe("parser", () => {
-  test("can parse a function call with no argument", () => {
-    expect(parse("RAND()")).toEqual({ type: "FUNCALL", value: "RAND", args: [] });
-  });
-
-  test("can parse a function call with one argument", () => {
-    expect(parse("SUM(1)")).toEqual({
-      type: "FUNCALL",
-      value: "SUM",
-      args: [{ type: "NUMBER", value: 1 }],
-    });
-  });
-
-  test("can parse a function call with sub expressions as argument", () => {
-    expect(parse("IF(|0| > 0, 1, 2)")).toEqual({
-      type: "FUNCALL",
-      value: "IF",
-      args: [
-        {
-          type: "BIN_OPERATION",
-          value: ">",
-          left: { type: "REFERENCE", value: 0 },
-          right: { type: "NUMBER", value: 0 },
-        },
-        { type: "NUMBER", value: 1 },
-        { type: "NUMBER", value: 2 },
-      ],
-    });
-  });
-
-  test("function without a opening parenthesis", () => {
-    expect(() => parse(`SUM 5`)).toThrow("wrong function call");
-  });
-
-  test("function without a closing parenthesis", () => {
-    expect(() => parse(`SUM(5`)).toThrow("wrong function call");
-  });
-
-  test("function without argument nor a closing parenthesis", () => {
-    expect(() => parse(`SUM(`)).toThrow("wrong function call");
-  });
-
-  test("function with empty first argument nor a closing parenthesis", () => {
-    expect(() => parse(`SUM(,`)).toThrow("invalid expression");
-  });
-
-  test("add a unknown token for empty arguments", () => {
-    expect(parse("SUM(1,)")).toEqual({
-      type: "FUNCALL",
-      value: "SUM",
-      args: [
-        { type: "NUMBER", value: 1 },
-        { type: "UNKNOWN", value: "" },
-      ],
-    });
-    expect(parse("SUM(,1)")).toEqual({
-      type: "FUNCALL",
-      value: "SUM",
-      args: [
-        { type: "UNKNOWN", value: "" },
-        { type: "NUMBER", value: 1 },
-      ],
-    });
-    expect(parse("SUM(,)")).toEqual({
-      type: "FUNCALL",
-      value: "SUM",
-      args: [
-        { type: "UNKNOWN", value: "" },
-        { type: "UNKNOWN", value: "" },
-      ],
-    });
-    expect(parse("SUM(,,)")).toEqual({
-      type: "FUNCALL",
-      value: "SUM",
-      args: [
-        { type: "UNKNOWN", value: "" },
-        { type: "UNKNOWN", value: "" },
-        { type: "UNKNOWN", value: "" },
-      ],
-    });
-    expect(parse("SUM(,,,1)")).toEqual({
-      type: "FUNCALL",
-      value: "SUM",
-      args: [
-        { type: "UNKNOWN", value: "" },
-        { type: "UNKNOWN", value: "" },
-        { type: "UNKNOWN", value: "" },
-        { type: "NUMBER", value: 1 },
-      ],
-    });
-  });
-
-  test("can parse unary operations", () => {
-    expect(parse("-1")).toEqual({
-      type: "UNARY_OPERATION",
-      value: "-",
-      right: { type: "NUMBER", value: 1 },
-    });
-    expect(parse("+1")).toEqual({
-      type: "UNARY_OPERATION",
-      value: "+",
-      right: { type: "NUMBER", value: 1 },
-    });
-  });
-  test("can parse numeric values", () => {
-    expect(parse("1")).toEqual({ type: "NUMBER", value: 1 });
-    expect(parse("1.5")).toEqual({ type: "NUMBER", value: 1.5 });
-    expect(parse("1.")).toEqual({ type: "NUMBER", value: 1 });
-    expect(parse(".5")).toEqual({ type: "NUMBER", value: 0.5 });
-  });
-
-  test("can parse string without ending double quotes", () => {
-    expect(parse('"hello')).toEqual({ type: "STRING", value: '"hello' });
-  });
-
-  test("can parse number expressed as percent", () => {
-    expect(parse("1%")).toEqual({ type: "NUMBER", value: 0.01 });
-    expect(parse("100%")).toEqual({ type: "NUMBER", value: 1 });
-    expect(parse("50.0%")).toEqual({ type: "NUMBER", value: 0.5 });
-  });
-
-  test("can parse binary operations", () => {
-    expect(parse("2-3")).toEqual({
-      type: "BIN_OPERATION",
-      value: "-",
-      left: { type: "NUMBER", value: 2 },
-      right: { type: "NUMBER", value: 3 },
-    });
-  });
-
-  test("can parse concat operator", () => {
-    expect(parse("|0|&|1|")).toEqual({
-      type: "BIN_OPERATION",
-      value: "&",
-      left: { type: "REFERENCE", value: 0 },
-      right: { type: "REFERENCE", value: 1 },
-    });
-  });
-
-  test("AND", () => {
-    expect(parse("=AND(true, false)")).toEqual({
-      type: "FUNCALL",
-      value: "AND",
-      args: [
-        { type: "BOOLEAN", value: true },
-        { type: "BOOLEAN", value: false },
-      ],
-    });
-    expect(parse("=AND(0, tRuE)")).toEqual({
-      type: "FUNCALL",
-      value: "AND",
-      args: [
-        { type: "NUMBER", value: 0 },
-        { type: "BOOLEAN", value: true },
-      ],
-    });
-  });
-
-  test("can parse async functions", () => {
-    expect(parse("=WAIT(12)")).toEqual({
-      type: "ASYNC_FUNCALL",
-      value: "WAIT",
-      args: [{ type: "NUMBER", value: 12 }],
-    });
-  });
-});
-
-describe("parsing other stuff", () => {
-  test("arbitrary text", () => {
-    expect(() => parse("=undefined")).toThrow();
-  });
-});
-describe("Converting AST to string", () => {
-  test("Convert number", () => {
-    expect(astToFormula(parse("1"), [])).toBe("1");
-  });
-  test("Convert string", () => {
-    expect(astToFormula(parse(`"hello"`), [])).toBe(`"hello"`);
-  });
-  test("Convert boolean", () => {
-    expect(astToFormula(parse("TRUE"), [])).toBe("TRUE");
-    expect(astToFormula(parse("FALSE"), [])).toBe("FALSE");
-  });
-  test("Convert unary operator", () => {
-    expect(astToFormula(parse("-45"), [])).toBe("-45");
-    expect(astToFormula(parse("+45"), [])).toBe("+45");
-  });
-  test("Convert binary operator", () => {
-    expect(astToFormula(parse("89-45"), [])).toBe("89-45");
-  });
-  test("Convert function", () => {
-    expect(astToFormula(parse("SUM(5,9,8)"), [])).toBe("SUM(5,9,8)");
-    expect(astToFormula(parse("-SUM(5,9,SUM(5,9,8))"), [])).toBe("-SUM(5,9,SUM(5,9,8))");
-  });
-  test("Convert normalized references", () => {
-    let { text, dependencies } = normalize("A10");
-    expect(astToFormula(parse(text), dependencies)).toBe("A10");
-    ({ text, dependencies } = normalize("Sheet1!A10"));
-    expect(astToFormula(parse(text), dependencies)).toBe("Sheet1!A10");
-    ({ text, dependencies } = normalize("'Sheet 1'!A10"));
-    expect(astToFormula(parse(text), dependencies)).toBe("'Sheet 1'!A10");
-    ({ text, dependencies } = normalize("'Sheet 1'!A10:A11"));
-    expect(astToFormula(parse(text), dependencies)).toBe("'Sheet 1'!A10:A11");
-    ({ text, dependencies } = normalize("SUM(A1,A2)"));
-    expect(astToFormula(parse(text), dependencies)).toBe("SUM(A1,A2)");
-  });
-  test("Convert normalized strings", () => {
-    let { text, dependencies } = normalize('"R"');
-    expect(astToFormula(parse(text), dependencies)).toBe('"R"');
-    ({ text, dependencies } = normalize('CONCAT("R", "EM")'));
-    expect(astToFormula(parse(text), dependencies)).toBe('CONCAT("R","EM")');
-  });
-  test("Convert normalized numbers", () => {
-    let { text, dependencies } = normalize("5");
-    expect(astToFormula(parse(text), dependencies)).toBe("5");
-    ({ text, dependencies } = normalize("5+4"));
-    expect(astToFormula(parse(text), dependencies)).toBe("5+4");
-    ({ text, dependencies } = normalize("+5"));
-    expect(astToFormula(parse(text), dependencies)).toBe("+5");
-  });
-});