@odoo/o-spreadsheet 14.0.0 → 14.0.1

package/tests/formulas/composer_tokenizer_test.ts

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,224 @@
+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");
+  });
+});