FIX: Several fixes on the FV function

(1+x)^(1+y) was stringifyfied incorrectly
We still need work on this

FV now returns currency

FV(-1,-2,1) should return #DIV/0! not #NUM!

base/src/expressions/parser/tests/mod.rs

@@ -0,0 +1,6 @@
+mod test_general;
+mod test_issue_155;
+mod test_move_formula;
+mod test_ranges;
+mod test_stringify;
+mod test_tables;

base/src/expressions/parser/tests/test_general.rs

@@ -0,0 +1,493 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::lexer::LexerMode;
+use crate::expressions::parser::stringify::{
+    to_rc_format, to_string, to_string_displaced, DisplaceData,
+};
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+
+struct Formula<'a> {
+    initial: &'a str,
+    expected: &'a str,
+}
+
+#[test]
+fn test_parser_reference() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("A2", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R[1]C[0]");
+}
+
+#[test]
+fn test_parser_absolute_column() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("$A1", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R[0]C1");
+}
+
+#[test]
+fn test_parser_absolute_row_col() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("$C$5", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R5C3");
+}
+
+#[test]
+fn test_parser_absolute_row_col_1() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("$A$1", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R1C1");
+}
+
+#[test]
+fn test_parser_simple_formula() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("C3+Sheet2!D4", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R[2]C[2]+Sheet2!R[3]C[3]");
+}
+
+#[test]
+fn test_parser_boolean() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("true", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "TRUE");
+}
+
+#[test]
+fn test_parser_bad_formula() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("#Value", &Some(cell_reference));
+    match &t {
+        Node::ParseErrorKind {
+            formula,
+            message,
+            position,
+        } => {
+            assert_eq!(formula, "#Value");
+            assert_eq!(message, "Invalid error.");
+            assert_eq!(*position, 1);
+        }
+        _ => {
+            panic!("Expected error in formula");
+        }
+    }
+    assert_eq!(to_rc_format(&t), "#Value");
+}
+
+#[test]
+fn test_parser_bad_formula_1() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("<5", &Some(cell_reference));
+    match &t {
+        Node::ParseErrorKind {
+            formula,
+            message,
+            position,
+        } => {
+            assert_eq!(formula, "<5");
+            assert_eq!(message, "Unexpected token: 'COMPARE'");
+            assert_eq!(*position, 0);
+        }
+        _ => {
+            panic!("Expected error in formula");
+        }
+    }
+    assert_eq!(to_rc_format(&t), "<5");
+}
+
+#[test]
+fn test_parser_bad_formula_2() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("*5", &Some(cell_reference));
+    match &t {
+        Node::ParseErrorKind {
+            formula,
+            message,
+            position,
+        } => {
+            assert_eq!(formula, "*5");
+            assert_eq!(message, "Unexpected token: 'PRODUCT'");
+            assert_eq!(*position, 0);
+        }
+        _ => {
+            panic!("Expected error in formula");
+        }
+    }
+    assert_eq!(to_rc_format(&t), "*5");
+}
+
+#[test]
+fn test_parser_bad_formula_3() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("SUM(#VALVE!)", &Some(cell_reference));
+    match &t {
+        Node::ParseErrorKind {
+            formula,
+            message,
+            position,
+        } => {
+            assert_eq!(formula, "SUM(#VALVE!)");
+            assert_eq!(message, "Invalid error.");
+            assert_eq!(*position, 5);
+        }
+        _ => {
+            panic!("Expected error in formula");
+        }
+    }
+    assert_eq!(to_rc_format(&t), "SUM(#VALVE!)");
+}
+
+#[test]
+fn test_parser_formulas() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let formulas = vec![
+        Formula {
+            initial: "IF(C3:D4>2,B5,SUM(D1:D7))",
+            expected: "IF(R[2]C[2]:R[3]C[3]>2,R[4]C[1],SUM(R[0]C[3]:R[6]C[3]))",
+        },
+        Formula {
+            initial: "-A1",
+            expected: "-R[0]C[0]",
+        },
+        Formula {
+            initial: "#VALUE!",
+            expected: "#VALUE!",
+        },
+        Formula {
+            initial: "SUM(C3:D4)",
+            expected: "SUM(R[2]C[2]:R[3]C[3])",
+        },
+        Formula {
+            initial: "A1/(B1-C1)",
+            expected: "R[0]C[0]/(R[0]C[1]-R[0]C[2])",
+        },
+    ];
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    for formula in formulas {
+        let t = parser.parse(
+            formula.initial,
+            &Some(CellReferenceRC {
+                sheet: "Sheet1".to_string(),
+                row: 1,
+                column: 1,
+            }),
+        );
+        assert_eq!(to_rc_format(&t), formula.expected);
+        assert_eq!(to_string(&t, &cell_reference), formula.initial);
+    }
+}
+
+#[test]
+fn test_parser_r1c1_formulas() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+    parser.set_lexer_mode(LexerMode::R1C1);
+
+    let formulas = vec![
+        Formula {
+            initial: "IF(R[2]C[2]:R[3]C[3]>2,R[4]C[1],SUM(R[0]C[3]:R[6]C[3]))",
+            expected: "IF(E5:F6>2,D7,SUM(F3:F9))",
+        },
+        Formula {
+            initial: "-R[0]C[0]",
+            expected: "-C3",
+        },
+        Formula {
+            initial: "R[1]C[-1]+1",
+            expected: "B4+1",
+        },
+        Formula {
+            initial: "#VALUE!",
+            expected: "#VALUE!",
+        },
+        Formula {
+            initial: "SUM(R[2]C[2]:R[3]C[3])",
+            expected: "SUM(E5:F6)",
+        },
+        Formula {
+            initial: "R[-3]C[0]",
+            expected: "#REF!",
+        },
+        Formula {
+            initial: "R[0]C[-3]",
+            expected: "#REF!",
+        },
+        Formula {
+            initial: "R[-2]C[-2]",
+            expected: "A1",
+        },
+        Formula {
+            initial: "SIN(R[-3]C[-3])",
+            expected: "SIN(#REF!)",
+        },
+    ];
+
+    // Reference cell is Sheet1!C3
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 3,
+        column: 3,
+    };
+    for formula in formulas {
+        let t = parser.parse(
+            formula.initial,
+            &Some(CellReferenceRC {
+                sheet: "Sheet1".to_string(),
+                row: 1,
+                column: 1,
+            }),
+        );
+        assert_eq!(to_string(&t, &cell_reference), formula.expected);
+        assert_eq!(to_rc_format(&t), formula.initial);
+    }
+}
+
+#[test]
+fn test_parser_quotes() {
+    let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("C3+'Second Sheet'!D4", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second Sheet'!R[3]C[3]");
+}
+
+#[test]
+fn test_parser_escape_quotes() {
+    let worksheets = vec!["Sheet1".to_string(), "Second '2' Sheet".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second ''2'' Sheet'!R[3]C[3]");
+}
+
+#[test]
+fn test_parser_parenthesis() {
+    let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("(C3=\"Yes\")*5", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "(R[2]C[2]=\"Yes\")*5");
+}
+
+#[test]
+fn test_parser_excel_xlfn() {
+    let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("_xlfn.CONCAT(C3)", &Some(cell_reference));
+    assert_eq!(to_rc_format(&t), "CONCAT(R[2]C[2])");
+}
+
+#[test]
+fn test_to_string_displaced() {
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let node = parser.parse("C3", &Some(context.clone()));
+    let displace_data = DisplaceData::Column {
+        sheet: 0,
+        column: 1,
+        delta: 4,
+    };
+    let t = to_string_displaced(&node, context, &displace_data);
+    assert_eq!(t, "G3".to_string());
+}
+
+#[test]
+fn test_to_string_displaced_full_ranges() {
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let node = parser.parse("SUM(3:3)", &Some(context.clone()));
+    let displace_data = DisplaceData::Column {
+        sheet: 0,
+        column: 1,
+        delta: 4,
+    };
+    assert_eq!(
+        to_string_displaced(&node, context, &displace_data),
+        "SUM(3:3)".to_string()
+    );
+
+    let node = parser.parse("SUM(D:D)", &Some(context.clone()));
+    let displace_data = DisplaceData::Row {
+        sheet: 0,
+        row: 3,
+        delta: 4,
+    };
+    assert_eq!(
+        to_string_displaced(&node, context, &displace_data),
+        "SUM(D:D)".to_string()
+    );
+}
+
+#[test]
+fn test_to_string_displaced_too_low() {
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let node = parser.parse("C3", &Some(context.clone()));
+    let displace_data = DisplaceData::Column {
+        sheet: 0,
+        column: 1,
+        delta: -40,
+    };
+    let t = to_string_displaced(&node, context, &displace_data);
+    assert_eq!(t, "#REF!".to_string());
+}
+
+#[test]
+fn test_to_string_displaced_too_high() {
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let node = parser.parse("C3", &Some(context.clone()));
+    let displace_data = DisplaceData::Column {
+        sheet: 0,
+        column: 1,
+        delta: 4000000,
+    };
+    let t = to_string_displaced(&node, context, &displace_data);
+    assert_eq!(t, "#REF!".to_string());
+}

base/src/expressions/parser/tests/test_issue_155.rs

@@ -0,0 +1,69 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn issue_155_parser() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 2,
+        column: 2,
+    };
+    let t = parser.parse("A$1:A2", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "A$1:A2");
+}
+
+#[test]
+fn issue_155_parser_case_2() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    let t = parser.parse("C$1:D2", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "C$1:D2");
+}
+
+#[test]
+fn issue_155_parser_only_row() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("A$2:B1", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "A1:B$2");
+}
+
+#[test]
+fn issue_155_parser_only_column() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("D1:$A3", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
+}

base/src/expressions/parser/tests/test_move_formula.rs

@@ -0,0 +1,480 @@
+use std::collections::HashMap;
+
+use crate::expressions::parser::move_formula::{move_formula, MoveContext};
+use crate::expressions::parser::Parser;
+use crate::expressions::types::{Area, CellReferenceRC};
+
+#[test]
+fn test_move_formula() {
+    // top left corner C2
+    let row = 2;
+    let column = 3;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row,
+        column,
+        width: 4,
+        height: 5,
+    };
+
+    // formula AB31 will not change
+    let node = parser.parse("AB31", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "AB31");
+
+    // formula $AB$31 will not change
+    let node = parser.parse("AB31", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "AB31");
+
+    // but formula D5 will change to N15  (N = D + 10)
+    let node = parser.parse("D5", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "N15");
+
+    // Also formula $D$5 will change to N15  (N = D + 10)
+    let node = parser.parse("$D$5", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "$N$15");
+}
+
+#[test]
+fn test_move_formula_context_offset() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+
+    let node = parser.parse("-X9+C2%", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "-X9+M12%");
+}
+
+#[test]
+fn test_move_formula_area_limits() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+
+    // Outside of the area. Not moved
+    let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "B2+B3+C1+G6+H5");
+
+    // In the area. Moved
+    let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "M12+P14+P15+P16");
+}
+
+#[test]
+fn test_move_formula_ranges() {
+    // top left corner C2
+    let row = 2;
+    let column = 3;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let area = &Area {
+        sheet: 0,
+        row,
+        column,
+        width: 4,
+        height: 5,
+    };
+    // Ranges inside the area are fully displaced (absolute or not)
+    let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(M12:P15)");
+
+    let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM($M$12:$P$15)");
+
+    // Ranges completely outside of the area are not touched
+    let node = parser.parse("SUM(A1:B3)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(A1:B3)");
+
+    let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM($A$1:$B$3)");
+
+    // Ranges that overlap with the area are also NOT displaced
+    let node = parser.parse("SUM(A1:F5)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(A1:F5)");
+
+    // Ranges that contain the area are also NOT displaced
+    let node = parser.parse("SUM(A1:X50)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(A1:X50)");
+}
+
+#[test]
+fn test_move_formula_wrong_reference() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    // Area is C2:G5
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Wrong formulas will NOT be displaced
+    let node = parser.parse("Sheet3!AB31", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "Sheet3!AB31");
+    let node = parser.parse("Sheet3!$X$9", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "Sheet3!$X$9");
+
+    let node = parser.parse("SUM(Sheet3!D2:D3)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(Sheet3!D2:D3)");
+}
+
+#[test]
+fn test_move_formula_misc() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+    let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "X9^M12-P14*H2");
+
+    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "P15*(-N15)*SUM(A1,X9,$N$15)");
+
+    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "IF(P15<-N15,X9&P15,FALSE)");
+}
+
+#[test]
+fn test_move_formula_another_sheet() {
+    // top left corner C2
+    let row = 2;
+    let column = 3;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    // we add two sheets and we cut/paste from Sheet1 to Sheet2
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row,
+        column,
+        width: 4,
+        height: 5,
+    };
+
+    // Formula AB31 and JJ3:JJ4 refers to original Sheet1!AB31 and Sheet1!JJ3:JJ4
+    let node = parser.parse(
+        "AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
+        &Some(context.clone()),
+    );
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet2",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(
+        t,
+        "Sheet1!AB31*SUM(Sheet1!JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(M12:P16)"
+    );
+}

base/src/expressions/parser/tests/test_ranges.rs

@@ -0,0 +1,102 @@
+use std::collections::HashMap;
+
+use crate::expressions::lexer::LexerMode;
+
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+struct Formula<'a> {
+    formula_a1: &'a str,
+    formula_r1c1: &'a str,
+}
+
+#[test]
+fn test_parser_formulas_with_full_ranges() {
+    let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    let formulas = vec![
+        Formula {
+            formula_a1: "IF(C:D>2,B5,SUM(D:D))",
+            formula_r1c1: "IF(R1C[2]:R1048576C[3]>2,R[4]C[1],SUM(R1C[3]:R1048576C[3]))",
+        },
+        Formula {
+            formula_a1: "A:A",
+            formula_r1c1: "R1C[0]:R1048576C[0]",
+        },
+        Formula {
+            formula_a1: "SUM(3:3)",
+            formula_r1c1: "SUM(R[2]C1:R[2]C16384)",
+        },
+        Formula {
+            formula_a1: "SUM($3:$3)",
+            formula_r1c1: "SUM(R3C1:R3C16384)",
+        },
+        Formula {
+            formula_a1: "SUM(Sheet1!3:$3)",
+            formula_r1c1: "SUM(Sheet1!R[2]C1:R3C16384)",
+        },
+        Formula {
+            formula_a1: "SUM('Second Sheet'!C:D)",
+            formula_r1c1: "SUM('Second Sheet'!R1C[2]:R1048576C[3])",
+        },
+    ];
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    for formula in &formulas {
+        let t = parser.parse(
+            formula.formula_a1,
+            &Some(CellReferenceRC {
+                sheet: "Sheet1".to_string(),
+                row: 1,
+                column: 1,
+            }),
+        );
+        assert_eq!(to_rc_format(&t), formula.formula_r1c1);
+        assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
+    }
+
+    // Now the inverse
+    parser.set_lexer_mode(LexerMode::R1C1);
+    for formula in &formulas {
+        let t = parser.parse(
+            formula.formula_r1c1,
+            &Some(CellReferenceRC {
+                sheet: "Sheet1".to_string(),
+                row: 1,
+                column: 1,
+            }),
+        );
+        assert_eq!(to_rc_format(&t), formula.formula_r1c1);
+        assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
+    }
+}
+
+#[test]
+fn test_range_inverse_order() {
+    let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    // D4:C2 => C2:D4
+    let t = parser.parse(
+        "SUM(D4:C2)*SUM(Sheet2!D4:C20)*SUM($C$20:D4)",
+        &Some(cell_reference.clone()),
+    );
+    assert_eq!(
+        to_string(&t, &cell_reference),
+        "SUM(C2:D4)*SUM(Sheet2!C4:D20)*SUM($C4:D$20)".to_string()
+    );
+}

base/src/expressions/parser/tests/test_stringify.rs

@@ -0,0 +1,34 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn exp_order() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("(1 + 2)^3  + 4", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
+
+    let t = parser.parse("(C5 + 3)^R4", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
+
+    let t = parser.parse("(C5 + 3)^(R4*6)", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
+
+    let t = parser.parse("(C5)^(R4)", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "C5^R4");
+
+    let t = parser.parse("(5)^(4)", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "5^4");
+}

base/src/expressions/parser/tests/test_tables.rs

@@ -0,0 +1,100 @@
+#![allow(clippy::unwrap_used)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::utils::{number_to_column, parse_reference_a1};
+use crate::types::{Table, TableColumn, TableStyleInfo};
+
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+fn create_test_table(
+    table_name: &str,
+    column_names: &[&str],
+    cell_ref: &str,
+    row_count: i32,
+) -> HashMap<String, Table> {
+    let mut table = HashMap::new();
+    let mut columns = Vec::new();
+    for (id, name) in column_names.iter().enumerate() {
+        columns.push(TableColumn {
+            id: id as u32,
+            name: name.to_string(),
+            ..Default::default()
+        })
+    }
+    let init_cell = parse_reference_a1(cell_ref).unwrap();
+    let start_row = init_cell.row;
+    let start_column = number_to_column(init_cell.column).unwrap();
+    let end_column = number_to_column(init_cell.column + column_names.len() as i32).unwrap();
+    let end_row = start_row + row_count - 1;
+
+    let area_ref = format!("{start_column}{start_row}:{end_column}{end_row}");
+
+    table.insert(
+        table_name.to_string(),
+        Table {
+            name: table_name.to_string(),
+            display_name: table_name.to_string(),
+            sheet_name: "Sheet One".to_string(),
+            reference: area_ref,
+            totals_row_count: 0,
+            header_row_count: 1,
+            header_row_dxf_id: None,
+            data_dxf_id: None,
+            columns,
+            style_info: TableStyleInfo {
+                ..Default::default()
+            },
+            totals_row_dxf_id: None,
+            has_filters: false,
+        },
+    );
+    table
+}
+
+#[test]
+fn simple_table() {
+    let worksheets = vec!["Sheet One".to_string(), "Second Sheet".to_string()];
+
+    // This is a table A1:F3, the column F has a formula
+    let column_names = ["Jan", "Feb", "Mar", "Apr", "Dec", "Year"];
+    let row_count = 3;
+    let tables = create_test_table("tblIncome", &column_names, "A1", row_count);
+
+    let mut parser = Parser::new(worksheets, tables);
+    // Reference cell is 'Sheet One'!F2
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet One".to_string(),
+        row: 2,
+        column: 6,
+    };
+
+    let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");
+
+    // Cell A3
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet One".to_string(),
+        row: 4,
+        column: 1,
+    };
+    let formula = "SUBTOTAL(109, tblIncome[Jan])";
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");
+
+    // Cell A3 in 'Second Sheet'
+    let cell_reference = CellReferenceRC {
+        sheet: "Second Sheet".to_string(),
+        row: 4,
+        column: 1,
+    };
+    let formula = "SUBTOTAL(109, tblIncome[Jan])";
+    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    assert_eq!(
+        to_string(&t, &cell_reference),
+        "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"
+    );
+}