new components for name manager dialog and fields

new text added to locale en_us

added name manager to toolbar

added model and worksheets as prop

UPDATE: API for defined names

NamedRange component changes

NameManager dialog component changes

new util formatting functions

UPDATE: API for defined names

new components for name manager dialog and fields

new text added to locale en_us

added name manager to toolbar

added model and worksheets as prop

UPDATE: API for defined names

NamedRange component changes

NameManager dialog component changes

new util formatting functions

UPDATE: API for defined names

last changes

corrected styling

updates to namedRange and nameManagerDialog

.github/workflows/publish-wiki.yml

@@ -1,18 +0,0 @@
-name: Publish wiki
-on:
-  push:
-    branches: [main]
-    paths:
-      - wiki/**
-      - .github/workflows/publish-wiki.yml
-concurrency:
-  group: publish-wiki
-  cancel-in-progress: true
-permissions:
-  contents: write
-jobs:
-  publish-wiki:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Andrew-Chen-Wang/github-wiki-action@v4

.github/workflows/test-coverage.yaml

@@ -1,6 +1,7 @@
 name: Coverage
 
-on: [pull_request]
+on:
+  workflow_dispatch:
 
 jobs:
   coverage:
@@ -14,10 +15,11 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate code coverage
-        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+        run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v5
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
         with:
-          token: ${{ secrets.CODECOV_TOKEN }}
           files: lcov.info
           fail_ci_if_error: true

.readthedocs.yaml

@@ -0,0 +1,32 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+    # You can also specify other tool versions:
+    # nodejs: "19"
+    # rust: "1.64"
+    # golang: "1.19"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: bindings/python/docs/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#    - pdf
+#    - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#    install:
+#    - requirements: docs/requirements.txt

CHANGELOG.md

@@ -0,0 +1,27 @@
+# CHANGELOG
+
+## Unreleased
+
+### Added
+
+- New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
+- New document server (Thanks Dani!)
+- New function FORMULATEXT
+
+### Fixed
+
+- Fixed several issues with pasting content
+- Fixed several issues with borders
+- Fixed bug where columns and rows could be resized to negative width and height, respectively
+
+## [0.2.0] - 2024-11-06 (The HN release)
+
+### Added
+
+- Rust crate ironcalc_base
+- Rust crate ironcalc
+- Minimal Python bindings (only Linux)
+- JavaScript bindings
+- React WebApp
+
+[0.2.0]: https://github.com/IronCalc/ironcalc/releases/tag/v0.2.0

CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# Contributing to IronCalc
+
+Whether you are a seasoned developer or a rookie, welcome to IronCalc! 
+
+🎉 We appreciate your interest in contributing to our project.
+
+Before starting any work it is best if you get in touch to make sure your work is relevant.
+
+Please be patient, I am only one and this is a side project.
+
+---
+
+## 🛠 Changes to the main repo
+
+If are comfortable working with GitHub and Git, the following steps should be straightforward. For more general information visit [GitHub Docs](https://docs.github.com/en) and [Git Documentation](https://git-scm.com/doc). 
+
+1. **Fork the repository**
+   Start by forking the repository to your own GitHub account. You can do this by clicking the "Fork" button on the top right of the repository page.
+
+2. **Clone the original repository**
+   Clone the original repository to your local machine:
+   ```bash
+   git clone https://github.com/ironcalc/IronCalc.git
+   cd IronCalc
+   ```
+
+
+3. **Add your fork as a remote**
+    Add your forked repository as a remote named fork:
+
+    ```bash
+    git remote add fork https://github.com/<your-username>/IronCalc.git
+    ```
+4. **Create a new branch**
+    Always create a new branch for your changes to keep your work isolated:
+
+    ```bash
+    git checkout -b your-feature-name
+    ```
+5. **Make changes**
+    Implement your changes, improvements, or bug fixes. Make sure to follow any coding style or project-specific guidelines.
+
+6. **Commit your changes**
+    Write clear and concise commit messages:
+
+    ```bash
+    git add .
+    git commit -m "Brief description of your changes"
+    ```
+7. **Push to your fork**
+    Push your branch to your forked repository:
+    ```bash
+    git push fork your-feature-name
+    ````
+
+8. **Create a Pull Request (PR)**
+   Follow the steps on the terminal or go to the orig IronCalc repository, and click on "New Pull Request."
+   Ensure your PR has a clear title and description explaining the purpose of your changes.
+
+Always start from the main branch in a clean state. `git pull` will generally get the lastest changes form the original repo.
+
+You should make sure that your changes are properly tested.
+
+# 🤝 Community and Support
+
+Feel free to reach out if you have questions or need help. Via GitHub, email, our discord server or bluesky.
+
+* Open an issue to report a bug or discuss a feature before implementing it.
+* Engage with the community to share ideas or seek guidance.
+
+Note that not all contributors need to be coding. To contribute testing, bug reports, typos, ideas of all kinds, you can just send us an email.
+
+Thank you for your contributions! 💪 Together, we can make IronCalc even better.

Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "adler"
@@ -43,6 +43,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "autocfg"
 version = "1.2.0"
@@ -57,19 +63,22 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "bitcode"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48bc1c27654127a24c476d40198746860ef56475f41a601bfa5c4d0f832968f0"
+checksum = "ee1bce7608560cd4bf0296a4262d0dbf13e6bcec5ff2105724c8ab88cc7fc784"
 dependencies = [
+ "arrayvec",
  "bitcode_derive",
  "bytemuck",
+ "glam",
+ "serde",
 ]
 
 [[package]]
 name = "bitcode_derive"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2966755a19aad59ee2aae91e2d48842c667a99d818ec72168efdab07200701cc"
+checksum = "a539389a13af092cd345a2b47ae7dec12deb306d660b2223d25cd3419b253ebe"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -142,9 +151,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.37"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -156,9 +165,9 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb"
+checksum = "cd6dd8046d00723a59a2f8c5f295c515b9bb9a331ee4f8f3d4dd49e428acd3b6"
 dependencies = [
  "chrono",
  "chrono-tz-build",
@@ -167,12 +176,11 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz-build"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1"
+checksum = "e94fea34d77a245229e7746bd2beb786cd2a896f306ff491fb8cecb3074b10a7"
 dependencies = [
  "parse-zoneinfo",
- "phf",
  "phf_codegen",
 ]
 
@@ -242,6 +250,27 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -299,6 +328,18 @@ dependencies = [
  "wasi",
 ]
 
+[[package]]
+name = "glam"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -331,6 +372,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "indoc"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+
 [[package]]
 name = "inout"
 version = "0.1.3"
@@ -342,7 +389,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -358,15 +405,17 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "bitcode",
  "chrono",
  "chrono-tz",
+ "csv",
  "js-sys",
  "once_cell",
  "rand",
  "regex",
+ "regex-lite",
  "ryu",
  "serde",
  "serde_json",
@@ -423,6 +472,15 @@ version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
 
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.7.2"
@@ -455,9 +513,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "parse-zoneinfo"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
 dependencies = [
  "regex",
 ]
@@ -529,6 +587,12 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
+[[package]]
+name = "portable-atomic"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -543,13 +607,86 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.79"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pyo3"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyroncalc"
+version = "0.1.2"
+dependencies = [
+ "ironcalc",
+ "pyo3",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.35"
@@ -612,6 +749,12 @@ dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.3"
@@ -714,15 +857,21 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
-version = "2.0.58"
+version = "2.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
 [[package]]
 name = "thiserror"
 version = "1.0.58"
@@ -774,6 +923,12 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
+[[package]]
+name = "unindent"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
+
 [[package]]
 name = "uuid"
 version = "1.8.0"

Cargo.toml

@@ -5,6 +5,7 @@ members = [
   "base",
   "xlsx",
   "bindings/wasm",
+  "bindings/python",
 ]
 
 exclude = [

Makefile

@@ -1,41 +1,45 @@
+.PHONY: lint
 lint:
 	cargo fmt -- --check
-	cargo clippy --all-targets --all-features
+	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
+	cd webapp && npm install && npm run check
 
+.PHONY: format
 format:
 	cargo fmt
 
+.PHONY: tests
 tests: lint
 	cargo test
-	./target/debug/documentation
-	cmp functions.md wiki/functions.md || exit 1
 	make remove-artifacts
-	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs
+	# Regretabbly we need to build the wasm twice, once for the nodejs tests
+	# and a second one for the vitest.
+	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
+	cd webapp && npm run test
+	cd bindings/python && ./run_tests.sh && ./run_examples.sh
 
+.PHONY: remove-artifacts
 remove-artifacts:
 	rm -f xlsx/hello-calc.xlsx
 	rm -f xlsx/hello-styles.xlsx
 	rm -f xlsx/widths-and-heights.xlsx
-	rm -f functions.md
 
+.PHONY: clean
 clean: remove-artifacts
 	cargo clean
 	rm -r -f base/target
 	rm -r -f xlsx/target
+	rm -r -f bindings/python/target
+	rm -r -f bindings/wasm/targets
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*
 
-
+.PHONY: coverage
 coverage:
 	CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
 	grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
 
-update-docs:
+.PHONY: docs
-	cargo build
-	./target/debug/documentation -o wiki/functions.md
-
 docs:
 	cargo doc --no-deps
-
-.PHONY: lint format tests docs coverage all

README.md

@@ -123,12 +123,12 @@ See https://github.com/ironcalc
 
 An early preview of the technology running entirely in your browser:
 
-https://playground.ironcalc.com
+https://app.ironcalc.com
 
 
 # Collaborators needed!. Call to action
 
-We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer (we need a logo desperately!), an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
+We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer, an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
 
 The best place to start will be to join or [discord channel](https://discord.gg/zZYWfh3RHJ) or send us an email at hello@ironcalc.com.
 

base/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ironcalc_base"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
@@ -14,10 +14,17 @@ readme = "README.md"
 serde = { version = "1.0", features = ["derive"] }
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.9"
+chrono-tz = "0.10"
-regex = "1.0"
+regex = { version = "1.0", optional = true}
+regex-lite = { version = "0.1.6", optional = true}
 once_cell = "1.16.0"
-bitcode = "0.6.0"
+bitcode = "0.6.3"
+csv = "1.3.0"
+
+[features]
+default = ["use_regex_full"]
+use_regex_full = ["regex"]
+use_regex_lite = ["regex-lite"]
 
 [dev-dependencies]
 serde_json = "1.0"

base/examples/formulas_and_errors.rs

@@ -3,15 +3,15 @@ use ironcalc_base::{types::CellType, Model};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut model = Model::new_empty("formulas-and-errors", "en", "UTC")?;
     // A1
-    model.set_user_input(0, 1, 1, "1".to_string());
+    model.set_user_input(0, 1, 1, "1".to_string())?;
     // A2
-    model.set_user_input(0, 2, 1, "2".to_string());
+    model.set_user_input(0, 2, 1, "2".to_string())?;
     // A3
-    model.set_user_input(0, 3, 1, "3".to_string());
+    model.set_user_input(0, 3, 1, "3".to_string())?;
     // B1
-    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string());
+    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string())?;
     // B2
-    model.set_user_input(0, 2, 2, "=B1/0".to_string());
+    model.set_user_input(0, 2, 2, "=B1/0".to_string())?;
     // Evaluate
     model.evaluate();
 

base/examples/hello_world.rs

@@ -3,11 +3,11 @@ use ironcalc_base::{cell::CellValue, Model};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut model = Model::new_empty("hello-world", "en", "UTC")?;
     // A1
-    model.set_user_input(0, 1, 1, "Hello".to_string());
+    model.set_user_input(0, 1, 1, "Hello".to_string())?;
     // B1
-    model.set_user_input(0, 1, 2, "world!".to_string());
+    model.set_user_input(0, 1, 2, "world!".to_string())?;
     // C1
-    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string());
+    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string())?;
     // evaluates
     model.evaluate();
 

base/src/actions.rs

@@ -79,12 +79,11 @@ impl Model {
         let formula_or_value = self
             .get_cell_formula(sheet, source_row, source_column)?
             .unwrap_or_else(|| source_cell.get_text(&self.workbook.shared_strings, &self.language));
-        self.set_user_input(sheet, target_row, target_column, formula_or_value);
+        self.set_user_input(sheet, target_row, target_column, formula_or_value)?;
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(target_row, target_column, style);
+            .set_cell_style(target_row, target_column, style)?;
-        self.cell_clear_all(sheet, source_row, source_column)?;
+        self.cell_clear_all(sheet, source_row, source_column)
-        Ok(())
     }
 
     /// Inserts one or more new columns into the model at the specified index.
@@ -384,11 +383,11 @@ impl Model {
     ///    * All cell references to initial_column will go to target_column
     ///    * All cell references to columns in between (initial_column, target_column] will be displaced one to the left
     ///    * All other cell references are left unchanged
-    /// Ranges. This is the tricky bit:
+    ///      Ranges. This is the tricky bit:
     ///    * Column is one of the extremes of the range. The new extreme would be target_column.
     ///      Range is then normalized
     ///    * Any other case, range is left unchanged.
-    /// NOTE: This does NOT move the data in the columns or move the colum styles
+    ///      NOTE: This does NOT move the data in the columns or move the colum styles
     pub fn move_column_action(
         &mut self,
         sheet: u32,

base/src/calc_result.rs

@@ -2,6 +2,7 @@ use std::cmp::Ordering;
 
 use crate::expressions::{token::Error, types::CellReferenceIndex};
 
+#[derive(Clone)]
 pub struct Range {
     pub left: CellReferenceIndex,
     pub right: CellReferenceIndex,

base/src/constants.rs

@@ -2,10 +2,12 @@
 /// COLUMN_WIDTH and ROW_HEIGHT are pixel values
 /// A column width of Excel value `w` will result in `w * COLUMN_WIDTH_FACTOR` pixels
 /// Note that these constants are inlined
-pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
-pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.0;
+pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
 pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
 pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
+pub(crate) const DEFAULT_WINDOW_HEIGHT: i64 = 600;
+pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;
 
 pub(crate) const LAST_COLUMN: i32 = 16_384;
 pub(crate) const LAST_ROW: i32 = 1_048_576;

base/src/diffs.rs

@@ -26,6 +26,7 @@ pub struct SetCellValue {
 }
 
 impl Model {
+    #[allow(clippy::expect_used)]
     pub(crate) fn shift_cell_formula(
         &mut self,
         sheet: u32,
@@ -57,6 +58,7 @@ impl Model {
         }
     }
 
+    #[allow(clippy::expect_used)]
     pub fn forward_references(
         &mut self,
         source_area: &Area,

base/src/expressions/lexer/test/test_util.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::expect_used)]
+
 use crate::expressions::{
     lexer::util::get_tokens,
     token::{OpCompare, OpSum, TokenType},
@@ -22,6 +24,25 @@ fn test_get_tokens() {
     assert_eq!(l.end, 10);
 }
 
+#[test]
+fn get_tokens_unicode() {
+    let formula = "'🇵🇭 Philippines'!A1";
+    let t = get_tokens(formula);
+    assert_eq!(t.len(), 1);
+
+    let expected = TokenType::Reference {
+        sheet: Some("🇵🇭 Philippines".to_string()),
+        row: 1,
+        column: 1,
+        absolute_column: false,
+        absolute_row: false,
+    };
+    let l = t.first().expect("expected token");
+    assert_eq!(l.token, expected);
+    assert_eq!(l.start, 0);
+    assert_eq!(l.end, 19);
+}
+
 #[test]
 fn test_simple_tokens() {
     assert_eq!(

base/src/expressions/lexer/util.rs

@@ -52,7 +52,9 @@ pub fn get_tokens(formula: &str) -> Vec<MarkedToken> {
     let mut lexer = Lexer::new(
         formula,
         LexerMode::A1,
+        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
+        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     let mut start = lexer.get_position();

base/src/expressions/parser/mod.rs

@@ -49,21 +49,15 @@ pub mod stringify;
 pub mod walk;
 
 #[cfg(test)]
-mod test;
+mod tests;
-
-#[cfg(test)]
-mod test_ranges;
-
-#[cfg(test)]
-mod test_move_formula;
-#[cfg(test)]
-mod test_tables;
 
 pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String> {
     let mut lexer = lexer::Lexer::new(
         formula,
         lexer::LexerMode::A1,
+        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
+        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     if let TokenType::Range {
@@ -170,7 +164,9 @@ pub enum Node {
         args: Vec<Node>,
     },
     ArrayKind(Vec<Node>),
-    VariableKind(String),
+    DefinedNameKind((String, Option<u32>)),
+    TableNameKind(String),
+    WrongVariableKind(String),
     CompareKind {
         kind: OpCompare,
         left: Box<Node>,
@@ -193,22 +189,35 @@ pub enum Node {
 pub struct Parser {
     lexer: lexer::Lexer,
     worksheets: Vec<String>,
-    context: Option<CellReferenceRC>,
+    defined_names: Vec<(String, Option<u32>)>,
+    context: CellReferenceRC,
     tables: HashMap<String, Table>,
 }
 
 impl Parser {
-    pub fn new(worksheets: Vec<String>, tables: HashMap<String, Table>) -> Parser {
+    pub fn new(
+        worksheets: Vec<String>,
+        defined_names: Vec<(String, Option<u32>)>,
+        tables: HashMap<String, Table>,
+    ) -> Parser {
         let lexer = lexer::Lexer::new(
             "",
             lexer::LexerMode::A1,
+            #[allow(clippy::expect_used)]
             get_locale("en").expect(""),
+            #[allow(clippy::expect_used)]
             get_language("en").expect(""),
         );
+        let context = CellReferenceRC {
+            sheet: worksheets.first().map_or("", |v| v).to_string(),
+            column: 1,
+            row: 1,
+        };
         Parser {
             lexer,
             worksheets,
-            context: None,
+            defined_names,
+            context,
             tables,
         }
     }
@@ -216,13 +225,18 @@ impl Parser {
         self.lexer.set_lexer_mode(mode)
     }
 
-    pub fn set_worksheets(&mut self, worksheets: Vec<String>) {
+    pub fn set_worksheets_and_names(
+        &mut self,
+        worksheets: Vec<String>,
+        defined_names: Vec<(String, Option<u32>)>,
+    ) {
         self.worksheets = worksheets;
+        self.defined_names = defined_names;
     }
 
-    pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
+    pub fn parse(&mut self, formula: &str, context: &CellReferenceRC) -> Node {
         self.lexer.set_formula(formula);
-        self.context.clone_from(context);
+        self.context = context.clone();
         self.parse_expr()
     }
 
@@ -236,6 +250,24 @@ impl Parser {
         None
     }
 
+    // Returns:
+    //  * None: If there is no defined name by that name
+    //  * Some(Some(index)): If there is a defined name local to that sheet
+    //  * Some(None): If there is a global defined name
+    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<Option<u32>> {
+        for (df_name, df_scope) in &self.defined_names {
+            if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
+                return Some(*df_scope);
+            }
+        }
+        for (df_name, df_scope) in &self.defined_names {
+            if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
+                return Some(None);
+            }
+        }
+        None
+    }
+
     fn parse_expr(&mut self) -> Node {
         let mut t = self.parse_concat();
         if let Node::ParseErrorKind { .. } = t {
@@ -450,16 +482,7 @@ impl Parser {
                 absolute_column,
                 absolute_row,
             } => {
-                let context = match &self.context {
+                let context = &self.context;
-                    Some(c) => c,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "Expected context for the reference".to_string(),
-                        }
-                    }
-                };
                 let sheet_index = match &sheet {
                     Some(name) => self.get_sheet_index_by_name(name),
                     None => self.get_sheet_index_by_name(&context.sheet),
@@ -494,16 +517,7 @@ impl Parser {
                 }
             }
             TokenType::Range { sheet, left, right } => {
-                let context = match &self.context {
+                let context = &self.context;
-                    Some(c) => c,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "Expected context for the reference".to_string(),
-                        }
-                    }
-                };
                 let sheet_index = match &sheet {
                     Some(name) => self.get_sheet_index_by_name(name),
                     None => self.get_sheet_index_by_name(&context.sheet),
@@ -518,20 +532,6 @@ impl Parser {
                 let mut absolute_row1 = left.absolute_row;
                 let mut absolute_row2 = right.absolute_row;
 
-                if self.lexer.is_a1_mode() {
-                    if !left.absolute_row {
-                        row1 -= context.row
-                    };
-                    if !left.absolute_column {
-                        column1 -= context.column
-                    };
-                    if !right.absolute_row {
-                        row2 -= context.row
-                    };
-                    if !right.absolute_column {
-                        column2 -= context.column
-                    };
-                }
                 if row1 > row2 {
                     (row2, row1) = (row1, row2);
                     (absolute_row2, absolute_row1) = (absolute_row1, absolute_row2);
@@ -540,6 +540,22 @@ impl Parser {
                     (column2, column1) = (column1, column2);
                     (absolute_column2, absolute_column1) = (absolute_column1, absolute_column2);
                 }
+
+                if self.lexer.is_a1_mode() {
+                    if !absolute_row1 {
+                        row1 -= context.row
+                    };
+                    if !absolute_column1 {
+                        column1 -= context.column
+                    };
+                    if !absolute_row2 {
+                        row2 -= context.row
+                    };
+                    if !absolute_column2 {
+                        column2 -= context.column
+                    };
+                }
+
                 match sheet_index {
                     Some(index) => Node::RangeKind {
                         sheet_name: sheet,
@@ -587,11 +603,33 @@ impl Parser {
                             kind: function_kind,
                             args,
                         };
-                    } else {
+                    }
-                        return Node::InvalidFunctionKind { name, args };
+                    return Node::InvalidFunctionKind { name, args };
+                }
+                let context = &self.context;
+
+                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                    Some(i) => i,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: "sheet not found".to_string(),
+                        };
+                    }
+                };
+
+                // Could be a defined name or a table
+                if let Some(scope) = self.get_defined_name(&name, context_sheet_index) {
+                    return Node::DefinedNameKind((name, scope));
+                }
+                let name_lower = name.to_lowercase();
+                for table_name in self.tables.keys() {
+                    if table_name.to_lowercase() == name_lower {
+                        return Node::TableNameKind(name);
                     }
                 }
-                Node::VariableKind(name)
+                Node::WrongVariableKind(name)
             }
             TokenType::Error(kind) => Node::ErrorKind(kind),
             TokenType::Illegal(error) => Node::ParseErrorKind {
@@ -663,177 +701,177 @@ impl Parser {
                 // We will try to convert to a normal reference
                 // table_name[column_name] => cell1:cell2
                 // table_name[[#This Row], [column_name]:[column_name]] => cell1:cell2
-                if let Some(context) = &self.context {
+                let context = &self.context;
-                    let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
-                        Some(i) => i,
+                    Some(i) => i,
-                        None => {
+                    None => {
-                            return Node::ParseErrorKind {
+                        return Node::ParseErrorKind {
-                                formula: self.lexer.get_formula(),
+                            formula: self.lexer.get_formula(),
-                                position: 0,
+                            position: 0,
-                                message: "sheet not found".to_string(),
+                            message: "sheet not found".to_string(),
-                            };
+                        };
-                        }
+                    }
-                    };
+                };
-                    // table-name => table
+                // table-name => table
-                    let table = self.tables.get(&table_name).unwrap_or_else(|| {
+                let table = match self.tables.get(&table_name) {
-                        panic!(
+                    Some(t) => t,
+                    None => {
+                        let message = format!(
                             "Table not found: '{table_name}' at '{}!{}{}'",
                             context.sheet,
-                            number_to_column(context.column).expect(""),
+                            number_to_column(context.column)
+                                .unwrap_or(format!("{}", context.column)),
                             context.row
-                        )
+                        );
-                    });
+                        return Node::ParseErrorKind {
-                    let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
+                            formula: self.lexer.get_formula(),
-                        Some(i) => i,
+                            position: 0,
-                        None => {
+                            message,
-                            return Node::ParseErrorKind {
+                        };
-                                formula: self.lexer.get_formula(),
+                    }
-                                position: 0,
+                };
-                                message: "sheet not found".to_string(),
+                let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
-                            };
+                    Some(i) => i,
-                        }
+                    None => {
-                    };
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: "sheet not found".to_string(),
+                        };
+                    }
+                };
 
-                    let sheet_name = if table_sheet_index == context_sheet_index {
+                let sheet_name = if table_sheet_index == context_sheet_index {
-                        None
+                    None
-                    } else {
+                } else {
-                        Some(table.sheet_name.clone())
+                    Some(table.sheet_name.clone())
-                    };
+                };
 
-                    // context must be with tables.reference
+                // context must be with tables.reference
-                    let (column_start, mut row_start, column_end, mut row_end) =
+                #[allow(clippy::expect_used)]
-                        parse_range(&table.reference).expect("Failed parsing range");
+                let (column_start, mut row_start, column_end, mut row_end) =
+                    parse_range(&table.reference).expect("Failed parsing range");
 
-                    let totals_row_count = table.totals_row_count as i32;
+                let totals_row_count = table.totals_row_count as i32;
-                    let header_row_count = table.header_row_count as i32;
+                let header_row_count = table.header_row_count as i32;
-                    row_end -= totals_row_count;
+                row_end -= totals_row_count;
 
-                    match specifier {
+                match specifier {
-                        Some(token::TableSpecifier::ThisRow) => {
+                    Some(token::TableSpecifier::ThisRow) => {
-                            row_start = context.row;
+                        row_start = context.row;
-                            row_end = context.row;
+                        row_end = context.row;
-                        }
+                    }
-                        Some(token::TableSpecifier::Totals) => {
+                    Some(token::TableSpecifier::Totals) => {
-                            if totals_row_count != 0 {
+                        if totals_row_count != 0 {
-                                row_start = row_end + 1;
+                            row_start = row_end + 1;
-                                row_end = row_start;
-                            } else {
-                                // Table1[#Totals] is #REF! if Table1 does not have totals
-                                return Node::ErrorKind(token::Error::REF);
-                            }
-                        }
-                        Some(token::TableSpecifier::Headers) => {
                             row_end = row_start;
-                        }
+                        } else {
-                        Some(token::TableSpecifier::Data) => {
+                            // Table1[#Totals] is #REF! if Table1 does not have totals
-                            row_start += header_row_count;
+                            return Node::ErrorKind(token::Error::REF);
-                        }
-                        Some(token::TableSpecifier::All) => {
-                            if totals_row_count != 0 {
-                                row_end += 1;
-                            }
-                        }
-                        None => {
-                            // skip the headers
-                            row_start += header_row_count;
                         }
                     }
-                    match table_reference {
+                    Some(token::TableSpecifier::Headers) => {
-                        None => {
+                        row_end = row_start;
-                            return Node::RangeKind {
+                    }
-                                sheet_name,
+                    Some(token::TableSpecifier::Data) => {
-                                sheet_index: table_sheet_index,
+                        row_start += header_row_count;
-                                absolute_row1: true,
+                    }
-                                absolute_column1: true,
+                    Some(token::TableSpecifier::All) => {
-                                row1: row_start,
+                        if totals_row_count != 0 {
-                                column1: column_start,
+                            row_end += 1;
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: column_end,
-                            };
-                        }
-                        Some(TableReference::ColumnReference(s)) => {
-                            let column_index = match get_table_column_by_name(&s, table) {
-                                Some(s) => s + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {s} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-                            if row_start == row_end {
-                                return Node::ReferenceKind {
-                                    sheet_name,
-                                    sheet_index: table_sheet_index,
-                                    absolute_row: true,
-                                    absolute_column: true,
-                                    row: row_start,
-                                    column: column_index,
-                                };
-                            }
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: column_index,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: column_index,
-                            };
-                        }
-                        Some(TableReference::RangeReference((left, right))) => {
-                            let left_column_index = match get_table_column_by_name(&left, table) {
-                                Some(f) => f + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {left} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-
-                            let right_column_index = match get_table_column_by_name(&right, table) {
-                                Some(f) => f + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {right} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: left_column_index,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: right_column_index,
-                            };
                         }
                     }
+                    None => {
+                        // skip the headers
+                        row_start += header_row_count;
+                    }
                 }
-                Node::ParseErrorKind {
+                match table_reference {
-                    formula: self.lexer.get_formula(),
+                    None => Node::RangeKind {
-                    position: 0,
+                        sheet_name,
-                    message: "Structured references not supported in R1C1 mode".to_string(),
+                        sheet_index: table_sheet_index,
+                        absolute_row1: true,
+                        absolute_column1: true,
+                        row1: row_start,
+                        column1: column_start,
+                        absolute_row2: true,
+                        absolute_column2: true,
+                        row2: row_end,
+                        column2: column_end,
+                    },
+                    Some(TableReference::ColumnReference(s)) => {
+                        let column_index = match get_table_column_by_name(&s, table) {
+                            Some(s) => s + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!("Expecting column: {s} in table {table_name}"),
+                                };
+                            }
+                        };
+                        if row_start == row_end {
+                            return Node::ReferenceKind {
+                                sheet_name,
+                                sheet_index: table_sheet_index,
+                                absolute_row: true,
+                                absolute_column: true,
+                                row: row_start,
+                                column: column_index,
+                            };
+                        }
+                        Node::RangeKind {
+                            sheet_name,
+                            sheet_index: table_sheet_index,
+                            absolute_row1: true,
+                            absolute_column1: true,
+                            row1: row_start,
+                            column1: column_index,
+                            absolute_row2: true,
+                            absolute_column2: true,
+                            row2: row_end,
+                            column2: column_index,
+                        }
+                    }
+                    Some(TableReference::RangeReference((left, right))) => {
+                        let left_column_index = match get_table_column_by_name(&left, table) {
+                            Some(f) => f + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!(
+                                        "Expecting column: {left} in table {table_name}"
+                                    ),
+                                };
+                            }
+                        };
+
+                        let right_column_index = match get_table_column_by_name(&right, table) {
+                            Some(f) => f + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!(
+                                        "Expecting column: {right} in table {table_name}"
+                                    ),
+                                };
+                            }
+                        };
+                        Node::RangeKind {
+                            sheet_name,
+                            sheet_index: table_sheet_index,
+                            absolute_row1: true,
+                            absolute_column1: true,
+                            row1: row_start,
+                            column1: left_column_index,
+                            absolute_row2: true,
+                            absolute_column2: true,
+                            row2: row_end,
+                            column2: right_column_index,
+                        }
+                    }
                 }
             }
         }

base/src/expressions/parser/move_formula.rs

@@ -375,7 +375,9 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             }
             format!("{{{}}}", arguments)
         }
-        VariableKind(value) => value.to_string(),
+        DefinedNameKind((name, _)) => name.to_string(),
+        TableNameKind(name) => name.to_string(),
+        WrongVariableKind(name) => name.to_string(),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
             to_string_moved(left, move_context),

base/src/expressions/parser/stringify.rs

@@ -456,11 +456,69 @@ fn stringify(
             };
             format!("{}{}{}", x, kind, y)
         }
-        OpPowerKind { left, right } => format!(
+        OpPowerKind { left, right } => {
-            "{}^{}",
+            let x = match **left {
-            stringify(left, context, displace_data, use_original_name),
+                BooleanKind(_)
-            stringify(right, context, displace_data, use_original_name)
+                | NumberKind(_)
-        ),
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | DefinedNameKind(_)
+                | TableNameKind(_)
+                | WrongVariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(left, context, displace_data, use_original_name)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(left, context, displace_data, use_original_name)
+                ),
+            };
+            let y = match **right {
+                BooleanKind(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | DefinedNameKind(_)
+                | TableNameKind(_)
+                | WrongVariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(right, context, displace_data, use_original_name)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(right, context, displace_data, use_original_name)
+                ),
+            };
+            format!("{}^{}", x, y)
+        }
         InvalidFunctionKind { name, args } => {
             format_function(name, args, context, displace_data, use_original_name)
         }
@@ -489,7 +547,9 @@ fn stringify(
             }
             format!("{{{}}}", arguments)
         }
-        VariableKind(value) => value.to_string(),
+        TableNameKind(value) => value.to_string(),
+        DefinedNameKind((name, _)) => name.to_string(),
+        WrongVariableKind(name) => name.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
                 format!(
@@ -606,7 +666,90 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
         Node::ErrorKind(_) => {}
         Node::ParseErrorKind { .. } => {}
         Node::ArrayKind(_) => {}
-        Node::VariableKind(_) => {}
+        Node::DefinedNameKind(_) => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
         Node::EmptyArgKind => {}
     }
 }
+
+pub(crate) fn rename_defined_name_in_node(
+    node: &mut Node,
+    name: &str,
+    scope: Option<u32>,
+    new_name: &str,
+) {
+    match node {
+        // Rename
+        Node::DefinedNameKind((n, s)) => {
+            if name.to_lowercase() == n.to_lowercase() && *s == scope {
+                *n = new_name.to_string();
+            }
+        }
+        // Go next level
+        Node::OpRangeKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpConcatenateKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpSumKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpProductKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpPowerKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::FunctionKind { kind: _, args } => {
+            for arg in args {
+                rename_defined_name_in_node(arg, name, scope, new_name);
+            }
+        }
+        Node::InvalidFunctionKind { name: _, args } => {
+            for arg in args {
+                rename_defined_name_in_node(arg, name, scope, new_name);
+            }
+        }
+        Node::CompareKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::UnaryKind { kind: _, right } => {
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+
+        // Do nothing
+        Node::BooleanKind(_) => {}
+        Node::NumberKind(_) => {}
+        Node::StringKind(_) => {}
+        Node::ErrorKind(_) => {}
+        Node::ParseErrorKind { .. } => {}
+        Node::ArrayKind(_) => {}
+        Node::EmptyArgKind => {}
+        Node::ReferenceKind { .. } => {}
+        Node::RangeKind { .. } => {}
+        Node::WrongReferenceKind { .. } => {}
+        Node::WrongRangeKind { .. } => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
+    }
+}

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

@@ -1,17 +1,13 @@
+#![allow(clippy::panic)]
+
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::DisplaceData;
+use crate::expressions::parser::stringify::{
-
+    to_rc_format, to_string, to_string_displaced, DisplaceData,
-use super::super::types::CellReferenceRC;
-use super::Parser;
-use super::{
-    super::parser::{
-        stringify::{to_rc_format, to_string},
-        Node,
-    },
-    stringify::to_string_displaced,
 };
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
     initial: &'a str,
@@ -21,7 +17,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_reference() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -29,14 +25,14 @@ fn test_parser_reference() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("A2", &Some(cell_reference));
+    let t = parser.parse("A2", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -44,14 +40,14 @@ fn test_parser_absolute_column() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$A1", &Some(cell_reference));
+    let t = parser.parse("$A1", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -59,14 +55,14 @@ fn test_parser_absolute_row_col() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$C$5", &Some(cell_reference));
+    let t = parser.parse("$C$5", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -74,14 +70,14 @@ fn test_parser_absolute_row_col_1() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$A$1", &Some(cell_reference));
+    let t = parser.parse("$A$1", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -90,14 +86,14 @@ fn test_parser_simple_formula() {
         column: 1,
     };
 
-    let t = parser.parse("C3+Sheet2!D4", &Some(cell_reference));
+    let t = parser.parse("C3+Sheet2!D4", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -106,14 +102,14 @@ fn test_parser_boolean() {
         column: 1,
     };
 
-    let t = parser.parse("true", &Some(cell_reference));
+    let t = parser.parse("true", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -121,7 +117,7 @@ fn test_parser_bad_formula() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("#Value", &Some(cell_reference));
+    let t = parser.parse("#Value", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -142,7 +138,7 @@ fn test_parser_bad_formula() {
 #[test]
 fn test_parser_bad_formula_1() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -150,7 +146,7 @@ fn test_parser_bad_formula_1() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("<5", &Some(cell_reference));
+    let t = parser.parse("<5", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -171,7 +167,7 @@ fn test_parser_bad_formula_1() {
 #[test]
 fn test_parser_bad_formula_2() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -179,7 +175,7 @@ fn test_parser_bad_formula_2() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("*5", &Some(cell_reference));
+    let t = parser.parse("*5", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -200,7 +196,7 @@ fn test_parser_bad_formula_2() {
 #[test]
 fn test_parser_bad_formula_3() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -208,7 +204,7 @@ fn test_parser_bad_formula_3() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("SUM(#VALVE!)", &Some(cell_reference));
+    let t = parser.parse("SUM(#VALVE!)", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -229,7 +225,7 @@ fn test_parser_bad_formula_3() {
 #[test]
 fn test_parser_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -263,11 +259,11 @@ fn test_parser_formulas() {
     for formula in formulas {
         let t = parser.parse(
             formula.initial,
-            &Some(CellReferenceRC {
+            &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);
@@ -277,7 +273,7 @@ fn test_parser_formulas() {
 #[test]
 fn test_parser_r1c1_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
     parser.set_lexer_mode(LexerMode::R1C1);
 
     let formulas = vec![
@@ -328,11 +324,11 @@ fn test_parser_r1c1_formulas() {
     for formula in formulas {
         let t = parser.parse(
             formula.initial,
-            &Some(CellReferenceRC {
+            &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);
@@ -342,7 +338,7 @@ fn test_parser_r1c1_formulas() {
 #[test]
 fn test_parser_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -351,14 +347,14 @@ fn test_parser_quotes() {
         column: 1,
     };
 
-    let t = parser.parse("C3+'Second Sheet'!D4", &Some(cell_reference));
+    let t = parser.parse("C3+'Second Sheet'!D4", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -367,14 +363,14 @@ fn test_parser_escape_quotes() {
         column: 1,
     };
 
-    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(cell_reference));
+    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -383,14 +379,14 @@ fn test_parser_parenthesis() {
         column: 1,
     };
 
-    let t = parser.parse("(C3=\"Yes\")*5", &Some(cell_reference));
+    let t = parser.parse("(C3=\"Yes\")*5", &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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -399,7 +395,7 @@ fn test_parser_excel_xlfn() {
         column: 1,
     };
 
-    let t = parser.parse("_xlfn.CONCAT(C3)", &Some(cell_reference));
+    let t = parser.parse("_xlfn.CONCAT(C3)", &cell_reference);
     assert_eq!(to_rc_format(&t), "CONCAT(R[2]C[2])");
 }
 
@@ -411,9 +407,9 @@ fn test_to_string_displaced() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -431,9 +427,9 @@ fn test_to_string_displaced_full_ranges() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("SUM(3:3)", &Some(context.clone()));
+    let node = parser.parse("SUM(3:3)", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -444,7 +440,7 @@ fn test_to_string_displaced_full_ranges() {
         "SUM(3:3)".to_string()
     );
 
-    let node = parser.parse("SUM(D:D)", &Some(context.clone()));
+    let node = parser.parse("SUM(D:D)", context);
     let displace_data = DisplaceData::Row {
         sheet: 0,
         row: 3,
@@ -464,9 +460,9 @@ fn test_to_string_displaced_too_low() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -484,9 +480,9 @@ fn test_to_string_displaced_too_high() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,

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, vec![], 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", &cell_reference);
+    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, vec![], 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", &cell_reference);
+    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, vec![], 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", &cell_reference);
+    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, vec![], 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", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
+}

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

@@ -1,10 +1,8 @@
 use std::collections::HashMap;
 
 use crate::expressions::parser::move_formula::{move_formula, MoveContext};
-use crate::expressions::types::Area;
+use crate::expressions::parser::Parser;
-
+use crate::expressions::types::{Area, CellReferenceRC};
-use super::super::types::CellReferenceRC;
-use super::Parser;
 
 #[test]
 fn test_move_formula() {
@@ -17,7 +15,7 @@ fn test_move_formula() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -29,7 +27,7 @@ fn test_move_formula() {
     };
 
     // formula AB31 will not change
-    let node = parser.parse("AB31", &Some(context.clone()));
+    let node = parser.parse("AB31", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -45,7 +43,7 @@ fn test_move_formula() {
     assert_eq!(t, "AB31");
 
     // formula $AB$31 will not change
-    let node = parser.parse("AB31", &Some(context.clone()));
+    let node = parser.parse("AB31", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -61,7 +59,7 @@ fn test_move_formula() {
     assert_eq!(t, "AB31");
 
     // but formula D5 will change to N15  (N = D + 10)
-    let node = parser.parse("D5", &Some(context.clone()));
+    let node = parser.parse("D5", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -77,7 +75,7 @@ fn test_move_formula() {
     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 node = parser.parse("$D$5", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -104,7 +102,7 @@ fn test_move_formula_context_offset() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -115,7 +113,7 @@ fn test_move_formula_context_offset() {
         height: 5,
     };
 
-    let node = parser.parse("-X9+C2%", &Some(context.clone()));
+    let node = parser.parse("-X9+C2%", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -142,7 +140,7 @@ fn test_move_formula_area_limits() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -154,7 +152,7 @@ fn test_move_formula_area_limits() {
     };
 
     // Outside of the area. Not moved
-    let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
+    let node = parser.parse("B2+B3+C1+G6+H5", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -170,7 +168,7 @@ fn test_move_formula_area_limits() {
     assert_eq!(t, "B2+B3+C1+G6+H5");
 
     // In the area. Moved
-    let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
+    let node = parser.parse("C2+F4+F5+F6", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -197,7 +195,7 @@ fn test_move_formula_ranges() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let area = &Area {
         sheet: 0,
@@ -207,7 +205,7 @@ fn test_move_formula_ranges() {
         height: 5,
     };
     // Ranges inside the area are fully displaced (absolute or not)
-    let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
+    let node = parser.parse("SUM(C2:F5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -222,7 +220,7 @@ fn test_move_formula_ranges() {
     );
     assert_eq!(t, "SUM(M12:P15)");
 
-    let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
+    let node = parser.parse("SUM($C$2:$F$5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -238,7 +236,7 @@ fn test_move_formula_ranges() {
     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 node = parser.parse("SUM(A1:B3)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -253,7 +251,7 @@ fn test_move_formula_ranges() {
     );
     assert_eq!(t, "SUM(A1:B3)");
 
-    let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
+    let node = parser.parse("SUM($A$1:$B$3)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -269,7 +267,7 @@ fn test_move_formula_ranges() {
     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 node = parser.parse("SUM(A1:F5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -285,7 +283,7 @@ fn test_move_formula_ranges() {
     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 node = parser.parse("SUM(A1:X50)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -320,10 +318,10 @@ fn test_move_formula_wrong_reference() {
         height: 5,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Wrong formulas will NOT be displaced
-    let node = parser.parse("Sheet3!AB31", &Some(context.clone()));
+    let node = parser.parse("Sheet3!AB31", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -337,7 +335,7 @@ fn test_move_formula_wrong_reference() {
         },
     );
     assert_eq!(t, "Sheet3!AB31");
-    let node = parser.parse("Sheet3!$X$9", &Some(context.clone()));
+    let node = parser.parse("Sheet3!$X$9", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -352,7 +350,7 @@ fn test_move_formula_wrong_reference() {
     );
     assert_eq!(t, "Sheet3!$X$9");
 
-    let node = parser.parse("SUM(Sheet3!D2:D3)", &Some(context.clone()));
+    let node = parser.parse("SUM(Sheet3!D2:D3)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -379,7 +377,7 @@ fn test_move_formula_misc() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -389,7 +387,7 @@ fn test_move_formula_misc() {
         width: 4,
         height: 5,
     };
-    let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
+    let node = parser.parse("X9^C2-F4*H2", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -404,7 +402,7 @@ fn test_move_formula_misc() {
     );
     assert_eq!(t, "X9^M12-P14*H2");
 
-    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
+    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -419,7 +417,7 @@ fn test_move_formula_misc() {
     );
     assert_eq!(t, "P15*(-N15)*SUM(A1,X9,$N$15)");
 
-    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
+    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -447,7 +445,7 @@ fn test_move_formula_another_sheet() {
     };
     // 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());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -459,10 +457,7 @@ fn test_move_formula_another_sheet() {
     };
 
     // Formula AB31 and JJ3:JJ4 refers to original Sheet1!AB31 and Sheet1!JJ3:JJ4
-    let node = parser.parse(
+    let node = parser.parse("AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)", context);
-        "AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
-        &Some(context.clone()),
-    );
     let t = move_formula(
         &node,
         &MoveContext {

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

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
 
-use super::super::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
-use super::super::types::CellReferenceRC;
+use crate::expressions::parser::Parser;
-use super::Parser;
+use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
     formula_a1: &'a str,
@@ -14,7 +14,7 @@ struct Formula<'a> {
 #[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 mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -52,11 +52,11 @@ fn test_parser_formulas_with_full_ranges() {
     for formula in &formulas {
         let t = parser.parse(
             formula.formula_a1,
-            &Some(CellReferenceRC {
+            &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);
@@ -67,11 +67,11 @@ fn test_parser_formulas_with_full_ranges() {
     for formula in &formulas {
         let t = parser.parse(
             formula.formula_r1c1,
-            &Some(CellReferenceRC {
+            &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);
@@ -81,7 +81,7 @@ fn test_parser_formulas_with_full_ranges() {
 #[test]
 fn test_range_inverse_order() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -93,7 +93,7 @@ fn test_range_inverse_order() {
     // D4:C2 => C2:D4
     let t = parser.parse(
         "SUM(D4:C2)*SUM(Sheet2!D4:C20)*SUM($C$20:D4)",
-        &Some(cell_reference.clone()),
+        &cell_reference,
     );
     assert_eq!(
         to_string(&t, &cell_reference),

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, vec![], 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", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
+
+    let t = parser.parse("(C5 + 3)^R4", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
+
+    let t = parser.parse("(C5 + 3)^(R4*6)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
+
+    let t = parser.parse("(C5)^(R4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "C5^R4");
+
+    let t = parser.parse("(5)^(4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "5^4");
+}

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

@@ -6,8 +6,8 @@ use crate::expressions::parser::stringify::to_string;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};
 
-use super::super::types::CellReferenceRC;
+use crate::expressions::parser::Parser;
-use super::Parser;
+use crate::expressions::types::CellReferenceRC;
 
 fn create_test_table(
     table_name: &str,
@@ -63,7 +63,7 @@ fn simple_table() {
     let row_count = 3;
     let tables = create_test_table("tblIncome", &column_names, "A1", row_count);
 
-    let mut parser = Parser::new(worksheets, tables);
+    let mut parser = Parser::new(worksheets, vec![], tables);
     // Reference cell is 'Sheet One'!F2
     let cell_reference = CellReferenceRC {
         sheet: "Sheet One".to_string(),
@@ -72,7 +72,7 @@ fn simple_table() {
     };
 
     let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");
 
     // Cell A3
@@ -82,7 +82,7 @@ fn simple_table() {
         column: 1,
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");
 
     // Cell A3 in 'Second Sheet'
@@ -92,7 +92,7 @@ fn simple_table() {
         column: 1,
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
     assert_eq!(
         to_string(&t, &cell_reference),
         "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"

base/src/expressions/parser/walk.rs

@@ -263,7 +263,9 @@ pub(crate) fn forward_references(
         // TODO: Not implemented
         Node::ArrayKind(_) => {}
         // Do nothing. Note: we could do a blanket _ => {}
-        Node::VariableKind(_) => {}
+        Node::DefinedNameKind(_) => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
         Node::ErrorKind(_) => {}
         Node::ParseErrorKind { .. } => {}
         Node::EmptyArgKind => {}

base/src/expressions/token.rs

@@ -79,7 +79,7 @@ impl fmt::Display for OpProduct {
 /// Note that "#ERROR!" and "#N/IMPL!" are not part of the xlsx standard
 ///  * "#ERROR!" means there was an error processing the formula (for instance "=A1+")
 ///  * "#N/IMPL!" means the formula or feature in Excel but has not been implemented in IronCalc
-/// Note that they are serialized/deserialized by index
+///    Note that they are serialized/deserialized by index
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Error {
     REF,

base/src/formatter/dates.rs

@@ -5,6 +5,7 @@ use chrono::NaiveDate;
 use crate::constants::EXCEL_DATE_BASE;
 
 pub fn from_excel_date(days: i64) -> NaiveDate {
+    #[allow(clippy::expect_used)]
     let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
     dt + Duration::days(days - 2)
 }

base/src/formatter/format.rs

@@ -245,6 +245,9 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         }
         ParsePart::Number(p) => {
             let mut text = "".to_string();
+            if let Some(c) = p.currency {
+                text = format!("{}", c);
+            }
             let tokens = &p.tokens;
             value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
             // p.precision is the number of significant digits _after_ the decimal point

base/src/formatter/lexer.rs

@@ -10,6 +10,7 @@ pub struct Lexer {
 pub enum Token {
     Color(i32),              // [Red] or [Color 23]
     Condition(Compare, f64), // [<=100] (Comparator, number)
+    Currency(char),          // [$€] ($ currency symbol)
     Literal(char), // €, $, (, ), /, :, +, -, ^, ', {, }, <, =, !, ~, > and space or scaped \X
     Spacer(char),  // *X
     Ghost(char),   // _X
@@ -274,6 +275,15 @@ impl Lexer {
                                 self.set_error("Failed to parse condition");
                                 Token::ILLEGAL
                             }
+                        } else if c == '$' {
+                            // currency
+                            self.read_next_char();
+                            if let Some(currency) = self.read_next_char() {
+                                self.read_next_char();
+                                return Token::Currency(currency);
+                            }
+                            self.set_error("Failed to parse currency");
+                            Token::ILLEGAL
                         } else {
                             // Color
                             if let Some(index) = self.consume_color() {

base/src/formatter/mod.rs

@@ -74,6 +74,7 @@ mod test;
 //
 // * Color [Red] or [Color 23] or [Color23]
 // * Conditions [<100]
+// * Currency [$€]
 // * Space _X when X is any given char
 // * A spacer of chars: *X where X is repeated as much as possible
 // * Literals: $, (, ), :, +, - and space

base/src/formatter/parser.rs

@@ -40,6 +40,7 @@ pub struct NumberPart {
     pub is_scientific: bool,
     pub scientific_minus: bool,
     pub exponent_digit_count: i32,
+    pub currency: Option<char>,
 }
 
 pub struct DatePart {
@@ -114,6 +115,7 @@ impl Parser {
         let mut exponent_digit_count = 0;
         let mut number = 'i';
         let mut index = 0;
+        let mut currency = None;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -170,6 +172,9 @@ impl Parser {
                 Token::Condition(cmp, value) => {
                     condition = Some((cmp, value));
                 }
+                Token::Currency(c) => {
+                    currency = Some(c);
+                }
                 Token::QuestionMark => {
                     tokens.push(TextToken::Digit(Digit {
                         kind: '?',
@@ -291,6 +296,7 @@ impl Parser {
                 is_scientific,
                 scientific_minus,
                 exponent_digit_count,
+                currency,
             })
         }
     }

base/src/formatter/test/test_general.rs

@@ -76,6 +76,14 @@ fn test_color() {
     assert_eq!(format_number(3.1, "[blue]0.00", locale).color, Some(4));
 }
 
+#[test]
+fn dollar_euro() {
+    let locale = get_default_locale();
+    let format = "[$€]#,##0.00";
+    let t = format_number(3.1, format, locale);
+    assert_eq!(t.text, "€3.10");
+}
+
 #[test]
 fn test_parts() {
     let locale = get_default_locale();

base/src/functions/engineering/transcendental/test_bessel.rs

@@ -12,7 +12,7 @@ const EPS_LOW: f64 = 1e-6;
 
 // Known values computed with Arb via Nemo.jl in Julia
 // You can also use Mathematica
-/// But please do not use Excel or any other software without arbitrary precision
+// But please do not use Excel or any other software without arbitrary precision
 
 fn numbers_are_close(a: f64, b: f64) -> bool {
     if a == b {

base/src/functions/financial.rs

@@ -89,6 +89,9 @@ fn compute_future_value(
     if rate == 0.0 {
         return Ok(-pv - pmt * nper);
     }
+    if rate == -1.0 && nper < 0.0 {
+        return Err((Error::DIV, "Divide by zero".to_string()));
+    }
 
     let rate_nper = (1.0 + rate).powf(nper);
     let fv = if period_start {
@@ -194,16 +197,24 @@ fn compute_ppmt(
 // In these formulas the payment (pmt) is normally negative
 
 impl Model {
-    // FIXME: These three functions (get_array_of_numbers..) need to be refactored
+    fn get_array_of_numbers_generic(
-    // They are really similar expect for small issues
-    fn get_array_of_numbers(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
+        accept_number_node: bool,
+        handle_empty_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
+        handle_non_number_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
     ) -> Result<Vec<f64>, CalcResult> {
         let mut values = Vec::new();
         match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) => values.push(value),
+            CalcResult::Number(value) if accept_number_node => values.push(value),
+            CalcResult::Number(_) => {
+                return Err(CalcResult::new_error(
+                    Error::VALUE,
+                    *cell,
+                    "Expected range of numbers".to_string(),
+                ));
+            }
             CalcResult::Range { left, right } => {
                 if left.sheet != right.sheet {
                     return Err(CalcResult::new_error(
@@ -212,6 +223,7 @@ impl Model {
                         "Ranges are in different sheets".to_string(),
                     ));
                 }
+                let sheet = left.sheet;
                 let row1 = left.row;
                 let mut row2 = right.row;
                 let column1 = left.column;
@@ -219,32 +231,46 @@ impl Model {
                 if row1 == 1 && row2 == LAST_ROW {
                     row2 = self
                         .workbook
-                        .worksheet(left.sheet)
+                        .worksheet(sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{}'", sheet),
+                            )
+                        })?
                         .dimension()
                         .max_row;
                 }
                 if column1 == 1 && column2 == LAST_COLUMN {
                     column2 = self
                         .workbook
-                        .worksheet(left.sheet)
+                        .worksheet(sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{}'", sheet),
+                            )
+                        })?
                         .dimension()
                         .max_column;
                 }
-                for row in row1..row2 + 1 {
+                for row in row1..=row2 {
-                    for column in column1..(column2 + 1) {
+                    for column in column1..=column2 {
-                        match self.evaluate_cell(CellReferenceIndex {
+                        let cell_ref = CellReferenceIndex { sheet, row, column };
-                            sheet: left.sheet,
+                        match self.evaluate_cell(cell_ref) {
-                            row,
+                            CalcResult::Number(value) => values.push(value),
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
                             error @ CalcResult::Error { .. } => return Err(error),
+                            CalcResult::EmptyCell => {
+                                if let Some(value) = handle_empty_cell()? {
+                                    values.push(value);
+                                }
+                            }
                             _ => {
-                                // We ignore booleans and strings
+                                if let Some(value) = handle_non_number_cell()? {
+                                    values.push(value);
+                                }
                             }
                         }
                     }
@@ -252,88 +278,51 @@ impl Model {
             }
             error @ CalcResult::Error { .. } => return Err(error),
             _ => {
-                // We ignore booleans and strings
+                handle_non_number_cell()?;
             }
-        };
+        }
         Ok(values)
     }
 
+    fn get_array_of_numbers(
+        &mut self,
+        arg: &Node,
+        cell: &CellReferenceIndex,
+    ) -> Result<Vec<f64>, CalcResult> {
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            true,        // accept_number_node
+            || Ok(None), // Ignore empty cells
+            || Ok(None), // Ignore non-number cells
+        )
+    }
+
     fn get_array_of_numbers_xpnv(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
         error: Error,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
+        self.get_array_of_numbers_generic(
-        match self.evaluate_node_in_context(arg, *cell) {
+            arg,
-            CalcResult::Number(value) => values.push(value),
+            cell,
-            CalcResult::Range { left, right } => {
+            true, // accept_number_node
-                if left.sheet != right.sheet {
+            || {
-                    return Err(CalcResult::new_error(
+                Err(CalcResult::new_error(
-                        Error::VALUE,
+                    Error::NUM,
-                        *cell,
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let row1 = left.row;
-                let mut row2 = right.row;
-                let column1 = left.column;
-                let mut column2 = right.column;
-                if row1 == 1 && row2 == LAST_ROW {
-                    row2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_row;
-                }
-                if column1 == 1 && column2 == LAST_COLUMN {
-                    column2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_column;
-                }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => {
-                                return Err(CalcResult::new_error(
-                                    Error::NUM,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    error,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
-                    error,
                     *cell,
                     "Expected number".to_string(),
-                ));
+                ))
-            }
+            },
-        };
+            || {
-        Ok(values)
+                Err(CalcResult::new_error(
+                    error.clone(),
+                    *cell,
+                    "Expected number".to_string(),
+                ))
+            },
+        )
     }
 
     fn get_array_of_numbers_xirr(
@@ -341,69 +330,19 @@ impl Model {
         arg: &Node,
         cell: &CellReferenceIndex,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
+        self.get_array_of_numbers_generic(
-        match self.evaluate_node_in_context(arg, *cell) {
+            arg,
-            CalcResult::Range { left, right } => {
+            cell,
-                if left.sheet != right.sheet {
+            false,            // Do not accept a single number node
-                    return Err(CalcResult::new_error(
+            || Ok(Some(0.0)), // Treat empty cells as zero
-                        Error::VALUE,
+            || {
-                        *cell,
+                Err(CalcResult::new_error(
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let row1 = left.row;
-                let mut row2 = right.row;
-                let column1 = left.column;
-                let mut column2 = right.column;
-                if row1 == 1 && row2 == LAST_ROW {
-                    row2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_row;
-                }
-                if column1 == 1 && column2 == LAST_COLUMN {
-                    column2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_column;
-                }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => values.push(0.0),
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    Error::VALUE,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
                     Error::VALUE,
                     *cell,
                     "Expected number".to_string(),
-                ));
+                ))
-            }
+            },
-        };
+        )
-        Ok(values)
     }
 
     /// PMT(rate, nper, pv, [fv], [type])
@@ -862,20 +801,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -1393,21 +1340,21 @@ impl Model {
         CalcResult::Number(result)
     }
 
-    /// This next three functions deal with Treasure Bills or T-Bills for short
+    // This next three functions deal with Treasure Bills or T-Bills for short
-    /// They are zero-coupon that mature in one year or less.
+    // They are zero-coupon that mature in one year or less.
-    ///  Definitions:
+    //  Definitions:
-    ///    $r$ be the discount rate
+    //    $r$ be the discount rate
-    ///    $v$ the face value of the Bill
+    //    $v$ the face value of the Bill
-    ///    $p$ the price of the Bill
+    //    $p$ the price of the Bill
-    ///    $d_m$ is the number of days from the settlement to maturity
+    //    $d_m$ is the number of days from the settlement to maturity
-    /// Then:
+    // Then:
-    ///   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
+    //   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
-    /// If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
+    // If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
-    /// $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
+    // $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
-    /// If d_m>= 183 days things are a bit more complicated.
+    // If d_m>= 183 days things are a bit more complicated.
-    /// Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
+    // Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
-    /// $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
+    // $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
-    /// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
+    // Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
 
     // TBILLEQ(settlement, maturity, discount)
     pub(crate) fn fn_tbilleq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {

base/src/functions/information.rs

@@ -247,45 +247,67 @@ impl Model {
             return CalcResult::Number(cell.sheet as f64 + 1.0);
         }
         // The arg could be a defined name or a table
-        let arg = &args[0];
+        // let  = &args[0];
-        if let Node::VariableKind(name) = arg {
+        match &args[0] {
-            // Let's see if it is a defined name
+            Node::DefinedNameKind((name, scope)) => {
-            if let Some(defined_name) = self.parsed_defined_names.get(&(None, name.to_lowercase()))
+                // Let's see if it is a defined name
-            {
+                if let Some(defined_name) = self
-                match defined_name {
+                    .parsed_defined_names
-                    ParsedDefinedName::CellReference(reference) => {
+                    .get(&(*scope, name.to_lowercase()))
-                        return CalcResult::Number(reference.sheet as f64 + 1.0)
+                {
+                    match defined_name {
+                        ParsedDefinedName::CellReference(reference) => {
+                            return CalcResult::Number(reference.sheet as f64 + 1.0)
+                        }
+                        ParsedDefinedName::RangeReference(range) => {
+                            return CalcResult::Number(range.left.sheet as f64 + 1.0)
+                        }
+                        ParsedDefinedName::InvalidDefinedNameFormula => {
+                            return CalcResult::Error {
+                                error: Error::ERROR,
+                                origin: cell,
+                                message: "Invalid name".to_string(),
+                            };
+                        }
                     }
-                    ParsedDefinedName::RangeReference(range) => {
+                } else {
-                        return CalcResult::Number(range.left.sheet as f64 + 1.0)
+                    // This should never happen
-                    }
+                    return CalcResult::Error {
-                    ParsedDefinedName::InvalidDefinedNameFormula => {
+                        error: Error::ERROR,
-                        return CalcResult::Error {
+                        origin: cell,
-                            error: Error::NA,
+                        message: "Invalid name".to_string(),
-                            origin: cell,
+                    };
-                            message: "Invalid name".to_string(),
+                }
-                        };
+            }
+            Node::TableNameKind(name) => {
+                // Now let's see if it is a table
+                for (table_name, table) in &self.workbook.tables {
+                    if table_name == name {
+                        if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
+                            return CalcResult::Number(sheet_index as f64 + 1.0);
+                        } else {
+                            break;
+                        }
                     }
                 }
             }
-            // Now let's see if it is a table
+            Node::WrongVariableKind(name) => {
-            for (table_name, table) in &self.workbook.tables {
+                return CalcResult::Error {
-                if table_name == name {
+                    error: Error::NAME,
-                    if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
+                    origin: cell,
-                        return CalcResult::Number(sheet_index as f64 + 1.0);
+                    message: format!("Name not found: {name}"),
-                    } else {
+                }
-                        break;
+            }
-                    }
+            arg => {
+                // Now it should be the name of a sheet
+                let sheet_name = match self.get_string(arg, cell) {
+                    Ok(s) => s,
+                    Err(e) => return e,
+                };
+                if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
+                    return CalcResult::Number(sheet_index as f64 + 1.0);
                 }
             }
-        }
-        // Now it should be the name of a sheet
-        let sheet_name = match self.get_string(arg, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-        if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
-            return CalcResult::Number(sheet_index as f64 + 1.0);
         }
         CalcResult::Error {
             error: Error::NA,

base/src/functions/logical.rs

@@ -66,88 +66,61 @@ impl Model {
     }
 
     pub(crate) fn fn_and(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut true_count = 0;
+        self.logical_nary(
-        for arg in args {
+            args,
-            match self.evaluate_node_in_context(arg, cell) {
+            cell,
-                CalcResult::Boolean(b) => {
+            |acc, value| acc.unwrap_or(true) && value,
-                    if !b {
+            Some(false),
-                        return CalcResult::Boolean(false);
+        )
-                    }
-                    true_count += 1;
-                }
-                CalcResult::Number(value) => {
-                    if value == 0.0 {
-                        return CalcResult::Boolean(false);
-                    }
-                    true_count += 1;
-                }
-                CalcResult::String(_value) => {
-                    true_count += 1;
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Boolean(b) => {
-                                    if !b {
-                                        return CalcResult::Boolean(false);
-                                    }
-                                    true_count += 1;
-                                }
-                                CalcResult::Number(value) => {
-                                    if value == 0.0 {
-                                        return CalcResult::Boolean(false);
-                                    }
-                                    true_count += 1;
-                                }
-                                CalcResult::String(_value) => {
-                                    true_count += 1;
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {}
-                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-            };
-        }
-        if true_count == 0 {
-            return CalcResult::new_error(
-                Error::VALUE,
-                cell,
-                "Boolean values not found".to_string(),
-            );
-        }
-        CalcResult::Boolean(true)
     }
 
     pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut result = false;
+        self.logical_nary(
+            args,
+            cell,
+            |acc, value| acc.unwrap_or(false) || value,
+            Some(true),
+        )
+    }
+
+    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.logical_nary(args, cell, |acc, value| acc.unwrap_or(false) ^ value, None)
+    }
+
+    /// Base function for AND, OR, XOR. These are all n-ary functions that perform a boolean operation on a series of
+    /// boolean values. These boolean values are sourced from `args`. Note that there is not a 1-1 relationship between
+    /// arguments and boolean values evaluated (see how Ranges are handled for example).
+    ///
+    /// Each argument in `args` is evaluated and the resulting value is interpreted as a boolean as follows:
+    /// - Boolean: The value is used directly.
+    /// - Number: 0 is FALSE, all other values are TRUE.
+    /// - Range: Each cell in the range is evaluated as if they were individual arguments with some caveats
+    /// - Empty arg: FALSE
+    /// - Empty cell & String: Ignored, behaves exactly like the argument wasn't passed in at all
+    /// - Error: Propagated
+    ///
+    /// If no arguments are provided, or all arguments are ignored, the function returns a #VALUE! error
+    ///
+    /// **`fold_fn`:** The function that combines the running result with the next value boolean value. The running result
+    /// starts as `None`.
+    ///
+    /// **`short_circuit_value`:** If the running result reaches `short_circuit_value`, the function returns early.
+    fn logical_nary(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+        fold_fn: fn(Option<bool>, bool) -> bool,
+        short_circuit_value: Option<bool>,
+    ) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let mut result = None;
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(value) => result = value || result,
+                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
-                CalcResult::Number(value) => {
+                CalcResult::Number(value) => result = Some(fold_fn(result, value != 0.0)),
-                    if value != 0.0 {
-                        return CalcResult::Boolean(true);
-                    }
-                }
-                CalcResult::String(_value) => {
-                    return CalcResult::Boolean(true);
-                }
                 CalcResult::Range { left, right } => {
                     if left.sheet != right.sheet {
                         return CalcResult::new_error(
@@ -163,94 +136,58 @@ impl Model {
                                 row,
                                 column,
                             }) {
-                                CalcResult::Boolean(value) => {
+                                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
-                                    result = value || result;
-                                }
                                 CalcResult::Number(value) => {
-                                    if value != 0.0 {
+                                    result = Some(fold_fn(result, value != 0.0))
-                                        return CalcResult::Boolean(true);
-                                    }
-                                }
-                                CalcResult::String(_value) => {
-                                    return CalcResult::Boolean(true);
                                 }
                                 error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {}
+                                CalcResult::EmptyArg => {} // unreachable
-                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                                CalcResult::Range { .. }
+                                | CalcResult::String { .. }
+                                | CalcResult::EmptyCell => {}
+                            }
+                            if let (Some(current_result), Some(short_circuit_value)) =
+                                (result, short_circuit_value)
+                            {
+                                if current_result == short_circuit_value {
+                                    return CalcResult::Boolean(current_result);
+                                }
                             }
                         }
                     }
                 }
                 error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                CalcResult::EmptyArg => result = Some(result.unwrap_or(false)),
-            };
+                // Strings are ignored unless they are "TRUE" or "FALSE" (case insensitive). EXCEPT if the string value
-        }
+                // comes from a reference, in which case it is always ignored regardless of its value.
-        CalcResult::Boolean(result)
+                CalcResult::String(..) => {
-    }
+                    if !matches!(arg, Node::ReferenceKind { .. }) {
-
+                        if let Ok(f) = self.get_boolean(arg, cell) {
-    /// XOR(logical1, [logical]*,...)
+                            result = Some(fold_fn(result, f));
-    /// Logical1 is required, subsequent logical values are optional. Can be logical values, arrays, or references.
-    /// The result of XOR is TRUE when the number of TRUE inputs is odd and FALSE when the number of TRUE inputs is even.
-    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut true_count = 0;
-        let mut false_count = 0;
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(b) => {
-                    if b {
-                        true_count += 1;
-                    } else {
-                        false_count += 1;
-                    }
-                }
-                CalcResult::Number(value) => {
-                    if value != 0.0 {
-                        true_count += 1;
-                    } else {
-                        false_count += 1;
-                    }
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Boolean(b) => {
-                                    if b {
-                                        true_count += 1;
-                                    } else {
-                                        false_count += 1;
-                                    }
-                                }
-                                CalcResult::Number(value) => {
-                                    if value != 0.0 {
-                                        true_count += 1;
-                                    } else {
-                                        false_count += 1;
-                                    }
-                                }
-                                _ => {}
-                            }
                         }
                     }
                 }
-                _ => {}
+                // References to empty cells are ignored. If all args are ignored the result is #VALUE!
-            };
+                CalcResult::EmptyCell => {}
+            }
+
+            if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
+            {
+                if current_result == short_circuit_value {
+                    return CalcResult::Boolean(current_result);
+                }
+            }
         }
-        if true_count == 0 && false_count == 0 {
+
-            return CalcResult::new_error(Error::VALUE, cell, "No booleans found".to_string());
+        if let Some(result) = result {
+            CalcResult::Boolean(result)
+        } else {
+            CalcResult::new_error(
+                Error::VALUE,
+                cell,
+                "No logical values in argument list".to_string(),
+            )
         }
-        CalcResult::Boolean(true_count % 2 == 1)
     }
 
     /// =SWITCH(expression, case1, value1, [case, value]*, [default])

base/src/functions/lookup_and_reference.rs

@@ -838,4 +838,43 @@ impl Model {
         };
         CalcResult::Range { left, right }
     }
+
+    pub(crate) fn fn_formulatext(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        if let CalcResult::Range { left, right } = self.evaluate_node_with_reference(&args[0], cell)
+        {
+            if left.sheet != right.sheet {
+                return CalcResult::Error {
+                    error: Error::ERROR,
+                    origin: cell,
+                    message: "3D ranges not supported".to_string(),
+                };
+            }
+            if left.row != right.row || left.column != right.column {
+                // FIXME: Implicit intersection or dynamic arrays
+                return CalcResult::Error {
+                    error: Error::ERROR,
+                    origin: cell,
+                    message: "argument must be a reference to a single cell".to_string(),
+                };
+            }
+            if let Ok(Some(f)) = self.get_cell_formula(left.sheet, left.row, left.column) {
+                CalcResult::String(f)
+            } else {
+                CalcResult::Error {
+                    error: Error::NA,
+                    origin: cell,
+                    message: "Reference does not have a formula".to_string(),
+                }
+            }
+        } else {
+            CalcResult::Error {
+                error: Error::ERROR,
+                origin: cell,
+                message: "Argument must be a reference".to_string(),
+            }
+        }
+    }
 }

base/src/functions/mathematical.rs

@@ -128,20 +128,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -195,20 +203,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {

base/src/functions/mod.rs

@@ -75,6 +75,7 @@ pub enum Function {
 
     // Information
     ErrorType,
+    Formulatext,
     Isblank,
     Iserr,
     Iserror,
@@ -122,6 +123,7 @@ pub enum Function {
     Textbefore,
     Textjoin,
     Trim,
+    Unicode,
     Upper,
     Value,
     Valuetotext,
@@ -138,6 +140,7 @@ pub enum Function {
     Countifs,
     Maxifs,
     Minifs,
+    Geomean,
 
     // Date and time
     Date,
@@ -246,7 +249,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 192> {
+    pub fn into_iter() -> IntoIter<Function, 195> {
         [
             Function::And,
             Function::False,
@@ -316,6 +319,7 @@ impl Function {
             Function::Search,
             Function::Text,
             Function::Trim,
+            Function::Unicode,
             Function::Upper,
             Function::Isnumber,
             Function::Isnontext,
@@ -330,6 +334,7 @@ impl Function {
             Function::Isodd,
             Function::Iseven,
             Function::ErrorType,
+            Function::Formulatext,
             Function::Isformula,
             Function::Type,
             Function::Sheet,
@@ -344,6 +349,7 @@ impl Function {
             Function::Countifs,
             Function::Maxifs,
             Function::Minifs,
+            Function::Geomean,
             Function::Year,
             Function::Day,
             Function::Month,
@@ -460,6 +466,7 @@ impl Function {
             Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
             Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
             Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
+            Function::Unicode => "_xlfn.UNICODE".to_string(),
             Function::Rri => "_xlfn.RRI".to_string(),
             Function::Pduration => "_xlfn.PDURATION".to_string(),
             Function::Bitand => "_xlfn.BITAND".to_string(),
@@ -479,6 +486,7 @@ impl Function {
             Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
             Function::Isformula => "_xlfn.ISFORMULA".to_string(),
             Function::Sheet => "_xlfn.SHEET".to_string(),
+            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
             _ => self.to_string(),
         }
     }
@@ -567,6 +575,7 @@ impl Function {
             "SEARCH" => Some(Function::Search),
             "TEXT" => Some(Function::Text),
             "TRIM" => Some(Function::Trim),
+            "UNICODE" | "_XLFN.UNICODE" => Some(Function::Unicode),
             "UPPER" => Some(Function::Upper),
 
             "REPT" => Some(Function::Rept),
@@ -588,6 +597,7 @@ impl Function {
             "ISODD" => Some(Function::Isodd),
             "ISEVEN" => Some(Function::Iseven),
             "ERROR.TYPE" => Some(Function::ErrorType),
+            "FORMULATEXT" | "_XLFN.FORMULATEXT" => Some(Function::Formulatext),
             "ISFORMULA" | "_XLFN.ISFORMULA" => Some(Function::Isformula),
             "TYPE" => Some(Function::Type),
             "SHEET" | "_XLFN.SHEET" => Some(Function::Sheet),
@@ -603,6 +613,7 @@ impl Function {
             "COUNTIFS" => Some(Function::Countifs),
             "MAXIFS" | "_XLFN.MAXIFS" => Some(Function::Maxifs),
             "MINIFS" | "_XLFN.MINIFS" => Some(Function::Minifs),
+            "GEOMEAN" => Some(Function::Geomean),
             // Date and Time
             "YEAR" => Some(Function::Year),
             "DAY" => Some(Function::Day),
@@ -779,6 +790,7 @@ impl fmt::Display for Function {
             Function::Search => write!(f, "SEARCH"),
             Function::Text => write!(f, "TEXT"),
             Function::Trim => write!(f, "TRIM"),
+            Function::Unicode => write!(f, "UNICODE"),
             Function::Upper => write!(f, "UPPER"),
             Function::Isnumber => write!(f, "ISNUMBER"),
             Function::Isnontext => write!(f, "ISNONTEXT"),
@@ -793,6 +805,7 @@ impl fmt::Display for Function {
             Function::Isodd => write!(f, "ISODD"),
             Function::Iseven => write!(f, "ISEVEN"),
             Function::ErrorType => write!(f, "ERROR.TYPE"),
+            Function::Formulatext => write!(f, "FORMULATEXT"),
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
@@ -808,6 +821,7 @@ impl fmt::Display for Function {
             Function::Countifs => write!(f, "COUNTIFS"),
             Function::Maxifs => write!(f, "MAXIFS"),
             Function::Minifs => write!(f, "MINIFS"),
+            Function::Geomean => write!(f, "GEOMEAN"),
             Function::Year => write!(f, "YEAR"),
             Function::Day => write!(f, "DAY"),
             Function::Month => write!(f, "MONTH"),
@@ -1012,6 +1026,7 @@ impl Model {
             Function::Search => self.fn_search(args, cell),
             Function::Text => self.fn_text(args, cell),
             Function::Trim => self.fn_trim(args, cell),
+            Function::Unicode => self.fn_unicode(args, cell),
             Function::Upper => self.fn_upper(args, cell),
             // Information
             Function::Isnumber => self.fn_isnumber(args, cell),
@@ -1027,6 +1042,7 @@ impl Model {
             Function::Isodd => self.fn_isodd(args, cell),
             Function::Iseven => self.fn_iseven(args, cell),
             Function::ErrorType => self.fn_errortype(args, cell),
+            Function::Formulatext => self.fn_formulatext(args, cell),
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
@@ -1042,6 +1058,7 @@ impl Model {
             Function::Countifs => self.fn_countifs(args, cell),
             Function::Maxifs => self.fn_maxifs(args, cell),
             Function::Minifs => self.fn_minifs(args, cell),
+            Function::Geomean => self.fn_geomean(args, cell),
             // Date and Time
             Function::Year => self.fn_year(args, cell),
             Function::Day => self.fn_day(args, cell),
@@ -1148,6 +1165,7 @@ impl Model {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::unwrap_used)]
     use std::{
         fs::File,
         io::{BufRead, BufReader},

base/src/functions/statistical.rs

@@ -381,11 +381,16 @@ impl Model {
         let right_row = first_range.right.row;
         let right_column = first_range.right.column;
 
-        let dimension = self
+        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
-            .workbook
+            Ok(s) => s.dimension(),
-            .worksheet(first_range.left.sheet)
+            Err(_) => {
-            .expect("Sheet expected during evaluation.")
+                return CalcResult::new_error(
-            .dimension();
+                    Error::ERROR,
+                    cell,
+                    format!("Invalid worksheet index: '{}'", first_range.left.sheet),
+                )
+            }
+        };
         let max_row = dimension.max_row;
         let max_column = dimension.max_column;
 
@@ -526,20 +531,28 @@ impl Model {
         let mut right_column = sum_range.right.column;
 
         if left_row == 1 && right_row == LAST_ROW {
-            right_row = self
+            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
-                .workbook
+                Ok(s) => s.dimension().max_row,
-                .worksheet(sum_range.left.sheet)
+                Err(_) => {
-                .expect("Sheet expected during evaluation.")
+                    return Err(CalcResult::new_error(
-                .dimension()
+                        Error::ERROR,
-                .max_row;
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
         if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = self
+            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
-                .workbook
+                Ok(s) => s.dimension().max_column,
-                .worksheet(sum_range.left.sheet)
+                Err(_) => {
-                .expect("Sheet expected during evaluation.")
+                    return Err(CalcResult::new_error(
-                .dimension()
+                        Error::ERROR,
-                .max_column;
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
 
         for row in left_row..right_row + 1 {
@@ -622,4 +635,85 @@ impl Model {
         }
         CalcResult::Number(max)
     }
+
+    pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut product = 1.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    product *= value;
+                }
+                CalcResult::Boolean(b) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                    } else {
+                        product *= if b { 1.0 } else { 0.0 };
+                        count += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    product *= value;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        product *= t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(product.powf(1.0 / count))
+    }
 }

base/src/functions/subtotal.rs

@@ -53,8 +53,13 @@ impl Model {
         false
     }
 
-    fn cell_hidden_status(&self, sheet_index: u32, row: i32, column: i32) -> CellTableStatus {
+    fn cell_hidden_status(
-        let worksheet = self.workbook.worksheet(sheet_index).expect("");
+        &self,
+        sheet_index: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<CellTableStatus, String> {
+        let worksheet = self.workbook.worksheet(sheet_index)?;
         let mut hidden = false;
         for row_style in &worksheet.rows {
             if row_style.r == row {
@@ -63,13 +68,13 @@ impl Model {
             }
         }
         if !hidden {
-            return CellTableStatus::Normal;
+            return Ok(CellTableStatus::Normal);
         }
         // The row is hidden we need to know if the table has filters
         if self.get_table_for_cell(sheet_index, row, column) {
-            CellTableStatus::Filtered
+            Ok(CellTableStatus::Filtered)
         } else {
-            CellTableStatus::Hidden
+            Ok(CellTableStatus::Hidden)
         }
     }
 
@@ -143,7 +148,11 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                    .map_err(|message| {
+                                        CalcResult::new_error(Error::ERROR, cell, message)
+                                    })?;
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -380,7 +389,14 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = match self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                {
+                                    Ok(s) => s,
+                                    Err(message) => {
+                                        return CalcResult::new_error(Error::ERROR, cell, message);
+                                    }
+                                };
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -449,7 +465,14 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = match self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                {
+                                    Ok(s) => s,
+                                    Err(message) => {
+                                        return CalcResult::new_error(Error::ERROR, cell, message);
+                                    }
+                                };
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }

base/src/functions/text.rs

@@ -151,7 +151,7 @@ impl Model {
     ///  * If find_text does not appear in within_text, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is not greater than zero, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is greater than the length of within_text, FIND and FINDB return the #VALUE! error value.
-    /// NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
+    ///    NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
     pub(crate) fn fn_find(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -203,7 +203,7 @@ impl Model {
     /// Same API as FIND but:
     ///  * Allows wildcards
     ///  * It is case insensitive
-    /// SEARCH(find_text, within_text, [start_num])
+    ///    SEARCH(find_text, within_text, [start_num])
     pub(crate) fn fn_search(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -342,6 +342,53 @@ impl Model {
         CalcResult::new_args_number_error(cell)
     }
 
+    pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() == 1 {
+            let s = match self.evaluate_node_in_context(&args[0], cell) {
+                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::String(v) => v,
+                CalcResult::Boolean(b) => {
+                    if b {
+                        "TRUE".to_string()
+                    } else {
+                        "FALSE".to_string()
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::Range { .. } => {
+                    // Implicit Intersection not implemented
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Implicit Intersection not implemented".to_string(),
+                    };
+                }
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Empty cell".to_string(),
+                    }
+                }
+            };
+
+            match s.chars().next() {
+                Some(c) => {
+                    let unicode_number = c as u32;
+                    return CalcResult::Number(unicode_number as f64);
+                }
+                None => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Empty cell".to_string(),
+                    };
+                }
+            }
+        }
+        CalcResult::new_args_number_error(cell)
+    }
+
     pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
@@ -503,7 +550,7 @@ impl Model {
             }
             result.push(ch);
         }
-        return CalcResult::String(result.chars().rev().collect::<String>());
+        CalcResult::String(result.chars().rev().collect::<String>())
     }
 
     pub(crate) fn fn_mid(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -888,20 +935,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
+                        row2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_row,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_row;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
+                        column2 = match self.workbook.worksheet(left.sheet) {
-                            .workbook
+                            Ok(s) => s.dimension().max_column,
-                            .worksheet(left.sheet)
+                            Err(_) => {
-                            .expect("Sheet expected during evaluation.")
+                                return CalcResult::new_error(
-                            .dimension()
+                                    Error::ERROR,
-                            .max_column;
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {

base/src/functions/util.rs

@@ -1,4 +1,5 @@
-use regex::{escape, Regex};
+#[cfg(feature = "use_regex_lite")]
+use regex_lite as regex;
 
 use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
 
@@ -25,9 +26,9 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
     }
 }
 
-/// In Excel there are two ways of comparing cell values.
+// In Excel there are two ways of comparing cell values.
-/// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
+// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
-/// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
+// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
 
 // ..., -2, -1, 0, 1, 2, ..., A-Z, FALSE, TRUE;
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
@@ -86,7 +87,7 @@ pub(crate) fn from_wildcard_to_regex(
     exact: bool,
 ) -> Result<regex::Regex, regex::Error> {
     // 1. Escape all
-    let reg = &escape(wildcard);
+    let reg = &regex::escape(wildcard);
 
     // 2. We convert the escaped '?' into '.' (matches a single character)
     let reg = &reg.replace("\\?", ".");
@@ -109,13 +110,13 @@ pub(crate) fn from_wildcard_to_regex(
 
     // And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?")
     if exact {
-        return Regex::new(&format!("^{}$", reg));
+        return regex::Regex::new(&format!("^{}$", reg));
     }
-    Regex::new(reg)
+    regex::Regex::new(reg)
 }
 
-/// NUMBERS ///
+// NUMBERS ///
-///*********///
+//*********///
 
 // It could be either the number or a string representation of the number
 // In the rest of the cases calc_result needs to be a number (cannot be the string "23", for instance)
@@ -180,8 +181,8 @@ fn result_is_not_equal_to_number(calc_result: &CalcResult, target: f64) -> bool
     }
 }
 
-/// BOOLEANS ///
+// BOOLEANS ///
-///**********///
+//**********///
 
 // Booleans have to be "exactly" equal
 fn result_is_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
@@ -198,12 +199,12 @@ fn result_is_not_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
     }
 }
 
-/// STRINGS ///
+// STRINGS ///
-///*********///
+//*********///
 
-/// Note that strings are case insensitive. `target` must always be lower case.
+// Note that strings are case insensitive. `target` must always be lower case.
 
-pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &Regex) -> bool {
+pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &regex::Regex) -> bool {
     match calc_result {
         CalcResult::String(s) => reg.is_match(&s.to_lowercase()),
         _ => false,
@@ -269,8 +270,8 @@ fn result_is_greater_or_equal_than_string(calc_result: &CalcResult, target: &str
     }
 }
 
-/// ERRORS ///
+// ERRORS ///
-///********///
+//********///
 
 fn result_is_equal_to_error(calc_result: &CalcResult, target: &str) -> bool {
     match calc_result {
@@ -286,8 +287,8 @@ fn result_is_not_equal_to_error(calc_result: &CalcResult, target: &str) -> bool
     }
 }
 
-/// EMPTY ///
+// EMPTY ///
-///*******///
+//*******///
 
 // Note that these two are not inverse of each other.
 // In particular, you can never match an empty cell.

base/src/functions/xlookup.rs

@@ -251,20 +251,28 @@ impl Model {
                         let column1 = left.column;
 
                         if row1 == 1 && row2 == LAST_ROW {
-                            row2 = self
+                            row2 = match self.workbook.worksheet(left.sheet) {
-                                .workbook
+                                Ok(s) => s.dimension().max_row,
-                                .worksheet(left.sheet)
+                                Err(_) => {
-                                .expect("Sheet expected during evaluation.")
+                                    return CalcResult::new_error(
-                                .dimension()
+                                        Error::ERROR,
-                                .max_row;
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         if column1 == 1 && column2 == LAST_COLUMN {
-                            column2 = self
+                            column2 = match self.workbook.worksheet(left.sheet) {
-                                .workbook
+                                Ok(s) => s.dimension().max_column,
-                                .worksheet(left.sheet)
+                                Err(_) => {
-                                .expect("Sheet expected during evaluation.")
+                                    return CalcResult::new_error(
-                                .dimension()
+                                        Error::ERROR,
-                                .max_column;
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         let left = CellReferenceIndex {
                             sheet: left.sheet,

base/src/language/mod.rs

@@ -31,6 +31,7 @@ pub struct Language {
     pub errors: Errors,
 }
 
+#[allow(clippy::expect_used)]
 static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
     bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
 });

base/src/lib.rs

@@ -25,6 +25,8 @@
 #![doc = include_str!("../examples/formulas_and_errors.rs")]
 //! ```
 
+#![warn(clippy::print_stdout)]
+
 pub mod calc_result;
 pub mod cell;
 pub mod expressions;
@@ -57,4 +59,6 @@ pub mod mock_time;
 
 pub use model::get_milliseconds_since_epoch;
 pub use model::Model;
+pub use user_model::BorderArea;
+pub use user_model::ClipboardData;
 pub use user_model::UserModel;

base/src/locale/mod.rs

@@ -65,6 +65,7 @@ pub struct DecimalFormats {
     pub standard: String,
 }
 
+#[allow(clippy::expect_used)]
 static LOCALES: Lazy<HashMap<String, Locale>> =
     Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
 

base/src/model.rs

@@ -7,19 +7,16 @@ use crate::{
     calc_result::{CalcResult, Range},
     cell::CellValue,
     constants::{self, LAST_COLUMN, LAST_ROW},
-    expressions::token::{Error, OpCompare, OpProduct, OpSum, OpUnary},
-    expressions::{
-        parser::move_formula::{move_formula, MoveContext},
-        token::get_error_by_name,
-        types::*,
-        utils::{self, is_valid_row},
-    },
     expressions::{
+        lexer::LexerMode,
         parser::{
-            stringify::{to_rc_format, to_string},
+            move_formula::{move_formula, MoveContext},
+            stringify::{rename_defined_name_in_node, to_rc_format, to_string},
             Node, Parser,
         },
-        utils::is_valid_column_number,
+        token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
+        types::*,
+        utils::{self, is_valid_column_number, is_valid_identifier, is_valid_row},
     },
     formatter::{
         format::{format_number, parse_formatted_number},
@@ -45,6 +42,7 @@ pub use crate::mock_time::get_milliseconds_since_epoch;
 /// * Or mocked for tests
 #[cfg(not(test))]
 #[cfg(not(target_arch = "wasm32"))]
+#[allow(clippy::expect_used)]
 pub fn get_milliseconds_since_epoch() -> i64 {
     use std::time::{SystemTime, UNIX_EPOCH};
     SystemTime::now()
@@ -75,6 +73,7 @@ pub(crate) enum CellState {
 }
 
 /// A parsed formula for a defined name
+#[derive(Clone)]
 pub(crate) enum ParsedDefinedName {
     /// CellReference (`=C4`)
     CellReference(CellReferenceIndex),
@@ -82,9 +81,6 @@ pub(crate) enum ParsedDefinedName {
     RangeReference(Range),
     /// `=SomethingElse`
     InvalidDefinedNameFormula,
-    // TODO: Support constants in defined names
-    // TODO: Support formulas in defined names
-    // TODO: Support tables in defined names
 }
 
 /// A dynamical IronCalc model.
@@ -94,11 +90,11 @@ pub(crate) enum ParsedDefinedName {
 /// * The Locale: a parsed version of the Workbook's locale
 /// * The Timezone: an object representing the Workbook's timezone
 /// * The language. Note that the timezone and the locale belong to the workbook while
-/// the language can be different for different users looking _at the same_ workbook.
+///   the language can be different for different users looking _at the same_ workbook.
 /// * Parsed Formulas: All the formulas in the workbook are parsed here (runtime only)
 /// * A list of cells with its status (evaluating, evaluated, not evaluated)
 /// * A dictionary with the shared strings and their indices.
-/// This is an optimization for large files (~1 million rows)
+///   This is an optimization for large files (~1 million rows)
 pub struct Model {
     /// A Rust internal representation of an Excel workbook
     pub workbook: Workbook,
@@ -420,38 +416,40 @@ impl Model {
                 // TODO: NOT IMPLEMENTED
                 CalcResult::new_error(Error::NIMPL, cell, "Arrays not implemented".to_string())
             }
-            VariableKind(defined_name) => {
+            DefinedNameKind((name, scope)) => {
-                let parsed_defined_name = self
+                if let Ok(Some(parsed_defined_name)) = self.get_parsed_defined_name(name, *scope) {
-                    .parsed_defined_names
-                    .get(&(Some(cell.sheet), defined_name.to_lowercase())) // try getting local defined name
-                    .or_else(|| {
-                        self.parsed_defined_names
-                            .get(&(None, defined_name.to_lowercase()))
-                    }); // fallback to global
-
-                if let Some(parsed_defined_name) = parsed_defined_name {
                     match parsed_defined_name {
                         ParsedDefinedName::CellReference(reference) => {
-                            self.evaluate_cell(*reference)
+                            self.evaluate_cell(reference)
                         }
                         ParsedDefinedName::RangeReference(range) => CalcResult::Range {
                             left: range.left,
                             right: range.right,
                         },
                         ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error(
-                            Error::NIMPL,
+                            Error::NAME,
                             cell,
-                            format!("Defined name \"{}\" is not a reference.", defined_name),
+                            format!("Defined name \"{}\" is not a reference.", name),
                         ),
                     }
                 } else {
                     CalcResult::new_error(
                         Error::NAME,
                         cell,
-                        format!("Defined name \"{}\" not found.", defined_name),
+                        format!("Defined name \"{}\" not found.", name),
                     )
                 }
             }
+            TableNameKind(s) => CalcResult::new_error(
+                Error::NAME,
+                cell,
+                format!("table name \"{}\" not supported.", s),
+            ),
+            WrongVariableKind(s) => CalcResult::new_error(
+                Error::NAME,
+                cell,
+                format!("Variable name \"{}\" not found.", s),
+            ),
             CompareKind { kind, left, right } => {
                 let l = self.evaluate_node_in_context(left, cell);
                 if l.is_error() {
@@ -533,6 +531,7 @@ impl Model {
         }
     }
 
+    #[allow(clippy::expect_used)]
     fn cell_reference_to_string(
         &self,
         cell_reference: &CellReferenceIndex,
@@ -548,6 +547,7 @@ impl Model {
     /// Sets `result` in the cell given by `sheet` sheet index, row and column
     /// Note that will panic if the cell does not exist
     /// It will do nothing if the cell does not have a formula
+    #[allow(clippy::expect_used)]
     fn set_cell_value(&mut self, cell_reference: CellReferenceIndex, result: &CalcResult) {
         let CellReferenceIndex { sheet, column, row } = cell_reference;
         let cell = &self.workbook.worksheets[sheet as usize].sheet_data[&row][&column];
@@ -683,6 +683,13 @@ impl Model {
         Err(format!("Invalid color: {}", color))
     }
 
+    /// Changes the visibility of a sheet
+    pub fn set_sheet_state(&mut self, sheet: u32, state: SheetState) -> Result<(), String> {
+        let worksheet = self.workbook.worksheet_mut(sheet)?;
+        worksheet.state = state;
+        Ok(())
+    }
+
     /// Makes the grid lines in the sheet visible (`true`) or hidden (`false`)
     pub fn set_show_grid_lines(&mut self, sheet: u32, show_grid_lines: bool) -> Result<(), String> {
         let worksheet = self.workbook.worksheet_mut(sheet)?;
@@ -858,6 +865,11 @@ impl Model {
 
         let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
 
+        let defined_names = workbook
+            .get_defined_names_with_scope()
+            .iter()
+            .map(|s| (s.0.to_owned(), s.1))
+            .collect();
         // add all tables
         // let mut tables = Vec::new();
         // for worksheet in worksheets {
@@ -867,7 +879,7 @@ impl Model {
         //     }
         //     tables.push(tables_in_sheet);
         // }
-        let parser = Parser::new(worksheet_names, workbook.tables.clone());
+        let parser = Parser::new(worksheet_names, defined_names, workbook.tables.clone());
         let cells = HashMap::new();
         let locale = get_locale(&workbook.settings.locale)
             .map_err(|_| "Invalid locale".to_string())?
@@ -879,6 +891,7 @@ impl Model {
             .map_err(|_| format!("Invalid timezone: {}", workbook.settings.tz))?;
 
         // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("").clone();
         let mut shared_strings = HashMap::new();
         for (index, s) in workbook.shared_strings.iter().enumerate() {
@@ -1027,7 +1040,7 @@ impl Model {
                 column: source.column,
             };
             let formula_str = move_formula(
-                &self.parser.parse(formula, &Some(cell_reference)),
+                &self.parser.parse(formula, &cell_reference),
                 &MoveContext {
                     source_sheet_name: &source_sheet_name,
                     row: source.row,
@@ -1135,7 +1148,7 @@ impl Model {
                 row: source.row,
                 column: source.column,
             };
-            let formula = &self.parser.parse(formula_str, &Some(cell_reference));
+            let formula = &self.parser.parse(formula_str, &cell_reference);
             let cell_reference = CellReferenceRC {
                 sheet: target_sheet_name,
                 row: target.row,
@@ -1204,10 +1217,10 @@ impl Model {
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "Hello!".to_string());
+    /// model.set_user_input(sheet, row, column, "Hello!".to_string())?;
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "Hello!".to_string());
     ///
-    /// model.update_cell_with_text(sheet, row, column, "Goodbye!");
+    /// model.update_cell_with_text(sheet, row, column, "Goodbye!")?;
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "Goodbye!".to_string());
     /// # Ok(())
     /// # }
@@ -1218,23 +1231,30 @@ impl Model {
     /// * [Model::update_cell_with_number()]
     /// * [Model::update_cell_with_bool()]
     /// * [Model::update_cell_with_formula()]
-    pub fn update_cell_with_text(&mut self, sheet: u32, row: i32, column: i32, value: &str) {
+    pub fn update_cell_with_text(
-        let style_index = self.get_cell_style_index(sheet, row, column);
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: &str,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index;
         if common::value_needs_quoting(value, &self.language) {
             new_style_index = self
                 .workbook
                 .styles
-                .get_style_with_quote_prefix(style_index);
+                .get_style_with_quote_prefix(style_index)?;
         } else if self.workbook.styles.style_is_quote_prefix(style_index) {
             new_style_index = self
                 .workbook
                 .styles
-                .get_style_without_quote_prefix(style_index);
+                .get_style_without_quote_prefix(style_index)?;
         } else {
             new_style_index = style_index;
         }
-        self.set_cell_with_string(sheet, row, column, value, new_style_index);
+
+        self.set_cell_with_string(sheet, row, column, value, new_style_index)
     }
 
     /// Updates the value of a cell with a boolean value
@@ -1247,10 +1267,10 @@ impl Model {
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "TRUE".to_string());
+    /// model.set_user_input(sheet, row, column, "TRUE".to_string())?;
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "TRUE".to_string());
     ///
-    /// model.update_cell_with_bool(sheet, row, column, false);
+    /// model.update_cell_with_bool(sheet, row, column, false)?;
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "FALSE".to_string());
     /// # Ok(())
     /// # }
@@ -1261,17 +1281,22 @@ impl Model {
     /// * [Model::update_cell_with_number()]
     /// * [Model::update_cell_with_text()]
     /// * [Model::update_cell_with_formula()]
-    pub fn update_cell_with_bool(&mut self, sheet: u32, row: i32, column: i32, value: bool) {
+    pub fn update_cell_with_bool(
-        let style_index = self.get_cell_style_index(sheet, row, column);
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: bool,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
             self.workbook
                 .styles
-                .get_style_without_quote_prefix(style_index)
+                .get_style_without_quote_prefix(style_index)?
         } else {
             style_index
         };
-        let worksheet = &mut self.workbook.worksheets[sheet as usize];
+        self.set_cell_with_boolean(sheet, row, column, value, new_style_index)
-        worksheet.set_cell_with_boolean(row, column, value, new_style_index);
     }
 
     /// Updates the value of a cell with a number
@@ -1284,10 +1309,10 @@ impl Model {
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "42".to_string());
+    /// model.set_user_input(sheet, row, column, "42".to_string())?;
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "42".to_string());
     ///
-    /// model.update_cell_with_number(sheet, row, column, 23.0);
+    /// model.update_cell_with_number(sheet, row, column, 23.0)?;
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "23".to_string());
     /// # Ok(())
     /// # }
@@ -1298,17 +1323,22 @@ impl Model {
     /// * [Model::update_cell_with_text()]
     /// * [Model::update_cell_with_bool()]
     /// * [Model::update_cell_with_formula()]
-    pub fn update_cell_with_number(&mut self, sheet: u32, row: i32, column: i32, value: f64) {
+    pub fn update_cell_with_number(
-        let style_index = self.get_cell_style_index(sheet, row, column);
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: f64,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
             self.workbook
                 .styles
-                .get_style_without_quote_prefix(style_index)
+                .get_style_without_quote_prefix(style_index)?
         } else {
             style_index
         };
-        let worksheet = &mut self.workbook.worksheets[sheet as usize];
+        self.set_cell_with_number(sheet, row, column, value, new_style_index)
-        worksheet.set_cell_with_number(row, column, value, new_style_index);
     }
 
     /// Updates the formula of given cell
@@ -1322,11 +1352,11 @@ impl Model {
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let mut model = Model::new_empty("model", "en", "UTC")?;
     /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "=A2*2".to_string());
+    /// model.set_user_input(sheet, row, column, "=A2*2".to_string())?;
     /// model.evaluate();
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "=A2*2".to_string());
     ///
-    /// model.update_cell_with_formula(sheet, row, column, "=A3*2".to_string());
+    /// model.update_cell_with_formula(sheet, row, column, "=A3*2".to_string())?;
     /// model.evaluate();
     /// assert_eq!(model.get_cell_content(sheet, row, column)?, "=A3*2".to_string());
     /// # Ok(())
@@ -1345,12 +1375,12 @@ impl Model {
         column: i32,
         formula: String,
     ) -> Result<(), String> {
-        let mut style_index = self.get_cell_style_index(sheet, row, column);
+        let mut style_index = self.get_cell_style_index(sheet, row, column)?;
         if self.workbook.styles.style_is_quote_prefix(style_index) {
             style_index = self
                 .workbook
                 .styles
-                .get_style_without_quote_prefix(style_index);
+                .get_style_without_quote_prefix(style_index)?;
         }
         let formula = formula
             .strip_prefix('=')
@@ -1390,31 +1420,36 @@ impl Model {
     /// * [Model::update_cell_with_number()]
     /// * [Model::update_cell_with_bool()]
     /// * [Model::update_cell_with_text()]
-    pub fn set_user_input(&mut self, sheet: u32, row: i32, column: i32, value: String) {
+    pub fn set_user_input(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: String,
+    ) -> Result<(), String> {
         // If value starts with "'" then we force the style to be quote_prefix
-        let style_index = self.get_cell_style_index(sheet, row, column);
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
             // First check if it needs quoting
             let new_style = if common::value_needs_quoting(new_value, &self.language) {
                 self.workbook
                     .styles
-                    .get_style_with_quote_prefix(style_index)
+                    .get_style_with_quote_prefix(style_index)?
             } else {
                 style_index
             };
-            self.set_cell_with_string(sheet, row, column, new_value, new_style);
+            self.set_cell_with_string(sheet, row, column, new_value, new_style)?;
         } else {
             let mut new_style_index = style_index;
             if self.workbook.styles.style_is_quote_prefix(style_index) {
                 new_style_index = self
                     .workbook
                     .styles
-                    .get_style_without_quote_prefix(style_index);
+                    .get_style_without_quote_prefix(style_index)?;
             }
             if let Some(formula) = value.strip_prefix('=') {
-                let formula_index = self
+                let formula_index =
-                    .set_cell_with_formula(sheet, row, column, formula, new_style_index)
+                    self.set_cell_with_formula(sheet, row, column, formula, new_style_index)?;
-                    .expect("could not set the cell formula");
                 // Update the style if needed
                 let cell = CellReferenceIndex { sheet, row, column };
                 let parsed_formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
@@ -1422,15 +1457,11 @@ impl Model {
                     let new_style_index = self
                         .workbook
                         .styles
-                        .get_style_with_format(new_style_index, &units.get_num_fmt());
+                        .get_style_with_format(new_style_index, &units.get_num_fmt())?;
-                    let style = self.workbook.styles.get_style(new_style_index);
+                    let style = self.workbook.styles.get_style(new_style_index)?;
-                    self.set_cell_style(sheet, row, column, &style)
+                    self.set_cell_style(sheet, row, column, &style)?
-                        .expect("Failed setting the style");
                 }
             } else {
-                let worksheets = &mut self.workbook.worksheets;
-                let worksheet = &mut worksheets[sheet as usize];
-
                 // The list of currencies is '$', '€' and the local currency
                 let mut currencies = vec!["$", "€"];
                 let currency = &self.locale.currency.symbol;
@@ -1443,35 +1474,39 @@ impl Model {
                         // Should not apply the format in the following cases:
                         // - we assign a date to already date-formatted cell
                         let should_apply_format = !(is_likely_date_number_format(
-                            &self.workbook.styles.get_style(new_style_index).num_fmt,
+                            &self.workbook.styles.get_style(new_style_index)?.num_fmt,
                         ) && is_likely_date_number_format(&num_fmt));
                         if should_apply_format {
                             new_style_index = self
                                 .workbook
                                 .styles
-                                .get_style_with_format(new_style_index, &num_fmt);
+                                .get_style_with_format(new_style_index, &num_fmt)?;
                         }
                     }
-                    worksheet.set_cell_with_number(row, column, v, new_style_index);
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
-                    return;
+                    worksheet.set_cell_with_number(row, column, v, new_style_index)?;
+                    return Ok(());
                 }
                 // We try to parse as boolean
                 if let Ok(v) = value.to_lowercase().parse::<bool>() {
-                    worksheet.set_cell_with_boolean(row, column, v, new_style_index);
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
-                    return;
+                    worksheet.set_cell_with_boolean(row, column, v, new_style_index)?;
+                    return Ok(());
                 }
                 // Check is it is error value
                 let upper = value.to_uppercase();
+                let worksheet = self.workbook.worksheet_mut(sheet)?;
                 match get_error_by_name(&upper, &self.language) {
                     Some(error) => {
-                        worksheet.set_cell_with_error(row, column, error, new_style_index);
+                        worksheet.set_cell_with_error(row, column, error, new_style_index)?;
                     }
                     None => {
-                        self.set_cell_with_string(sheet, row, column, &value, new_style_index);
+                        self.set_cell_with_string(sheet, row, column, &value, new_style_index)?;
                     }
                 }
             }
         }
+        Ok(())
     }
 
     fn set_cell_with_formula(
@@ -1489,13 +1524,11 @@ impl Model {
             column,
         };
         let shared_formulas = &mut worksheet.shared_formulas;
-        let mut parsed_formula = self.parser.parse(formula, &Some(cell_reference.clone()));
+        let mut parsed_formula = self.parser.parse(formula, &cell_reference);
         // If the formula fails to parse try adding a parenthesis
         // SUM(A1:A3  => SUM(A1:A3)
         if let Node::ParseErrorKind { .. } = parsed_formula {
-            let new_parsed_formula = self
+            let new_parsed_formula = self.parser.parse(&format!("{})", formula), &cell_reference);
-                .parser
-                .parse(&format!("{})", formula), &Some(cell_reference));
             match new_parsed_formula {
                 Node::ParseErrorKind { .. } => {}
                 _ => parsed_formula = new_parsed_formula,
@@ -1512,24 +1545,102 @@ impl Model {
             self.parsed_formulas[sheet as usize].push(parsed_formula);
             formula_index = (shared_formulas.len() as i32) - 1;
         }
-        worksheet.set_cell_with_formula(row, column, formula_index, style);
+        worksheet.set_cell_with_formula(row, column, formula_index, style)?;
         Ok(formula_index)
     }
 
-    fn set_cell_with_string(&mut self, sheet: u32, row: i32, column: i32, value: &str, style: i32) {
+    fn set_cell_with_string(
-        let worksheets = &mut self.workbook.worksheets;
+        &mut self,
-        let worksheet = &mut worksheets[sheet as usize];
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: &str,
+        style: i32,
+    ) -> Result<(), String> {
         match self.shared_strings.get(value) {
             Some(string_index) => {
-                worksheet.set_cell_with_string(row, column, *string_index as i32, style);
+                self.workbook.worksheet_mut(sheet)?.set_cell_with_string(
+                    row,
+                    column,
+                    *string_index as i32,
+                    style,
+                )?;
             }
             None => {
                 let string_index = self.workbook.shared_strings.len();
                 self.workbook.shared_strings.push(value.to_string());
                 self.shared_strings.insert(value.to_string(), string_index);
-                worksheet.set_cell_with_string(row, column, string_index as i32, style);
+                self.workbook.worksheet_mut(sheet)?.set_cell_with_string(
+                    row,
+                    column,
+                    string_index as i32,
+                    style,
+                )?;
             }
         }
+        Ok(())
+    }
+
+    fn set_cell_with_boolean(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: bool,
+        style: i32,
+    ) -> Result<(), String> {
+        self.workbook
+            .worksheet_mut(sheet)?
+            .set_cell_with_boolean(row, column, value, style)
+    }
+
+    fn set_cell_with_number(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: f64,
+        style: i32,
+    ) -> Result<(), String> {
+        self.workbook
+            .worksheet_mut(sheet)?
+            .set_cell_with_number(row, column, value, style)
+    }
+
+    // Helper function that returns a defined name given the name and scope
+    fn get_parsed_defined_name(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+    ) -> Result<Option<ParsedDefinedName>, String> {
+        let name_upper = name.to_uppercase();
+
+        for (key, df) in &self.parsed_defined_names {
+            if key.1.to_uppercase() == name_upper && key.0 == scope {
+                return Ok(Some(df.clone()));
+            }
+        }
+        Ok(None)
+    }
+
+    // Returns the formula for a defined name
+    pub(crate) fn get_defined_name_formula(
+        &self,
+        name: &str,
+        scope: Option<u32>,
+    ) -> Result<String, String> {
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                return Ok(df.formula.clone());
+            }
+        }
+        Err("Defined name not found".to_string())
     }
 
     /// Gets the Excel Value (Bool, Number, String) of a cell
@@ -1596,7 +1707,7 @@ impl Model {
     ) -> Result<String, String> {
         match self.workbook.worksheet(sheet_index)?.cell(row, column) {
             Some(cell) => {
-                let format = self.get_style_for_cell(sheet_index, row, column).num_fmt;
+                let format = self.get_style_for_cell(sheet_index, row, column)?.num_fmt;
                 let formatted_value =
                     cell.formatted_value(&self.workbook.shared_strings, &self.language, |value| {
                         format_number(value, &format, &self.locale).text
@@ -1699,7 +1810,7 @@ impl Model {
     pub fn cell_clear_contents(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
         self.workbook
             .worksheet_mut(sheet)?
-            .cell_clear_contents(row, column);
+            .cell_clear_contents(row, column)?;
         Ok(())
     }
 
@@ -1734,43 +1845,40 @@ impl Model {
     }
 
     /// Returns the style index for cell (`sheet`, `row`, `column`)
-    pub fn get_cell_style_index(&self, sheet: u32, row: i32, column: i32) -> i32 {
+    pub fn get_cell_style_index(&self, sheet: u32, row: i32, column: i32) -> Result<i32, String> {
         // First check the cell, then row, the column
-        let cell = self
+        let cell = self.workbook.worksheet(sheet)?.cell(row, column);
-            .workbook
+
-            .worksheet(sheet)
-            .expect("Invalid sheet")
-            .cell(row, column);
         match cell {
-            Some(cell) => cell.get_style(),
+            Some(cell) => Ok(cell.get_style()),
             None => {
-                let rows = &self.workbook.worksheets[sheet as usize].rows;
+                let rows = &self.workbook.worksheet(sheet)?.rows;
                 for r in rows {
                     if r.r == row {
                         if r.custom_format {
-                            return r.s;
+                            return Ok(r.s);
                         }
                         break;
                     }
                 }
-                let cols = &self.workbook.worksheets[sheet as usize].cols;
+                let cols = &self.workbook.worksheet(sheet)?.cols;
                 for c in cols.iter() {
                     let min = c.min;
                     let max = c.max;
                     if column >= min && column <= max {
-                        return c.style.unwrap_or(0);
+                        return Ok(c.style.unwrap_or(0));
                     }
                 }
-                0
+                Ok(0)
             }
         }
     }
 
     /// Returns the style for cell (`sheet`, `row`, `column`)
-    pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Style {
+    pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
-        self.workbook
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
-            .styles
+        let style = self.workbook.styles.get_style(style_index)?;
-            .get_style(self.get_cell_style_index(sheet, row, column))
+        Ok(style)
     }
 
     /// Returns an internal binary representation of the workbook
@@ -1810,7 +1918,7 @@ impl Model {
                     Some(formula) => formula,
                     None => self.get_formatted_cell_value(sheet, row, column)?,
                 };
-                let style = self.get_style_for_cell(sheet, row, column);
+                let style = self.get_style_for_cell(sheet, row, column)?;
                 if style.font.b {
                     cell_markup = format!("**{cell_markup}**")
                 }
@@ -1925,10 +2033,142 @@ impl Model {
             .worksheet_mut(sheet)?
             .set_row_height(column, height)
     }
+
+    /// Adds a new defined name
+    pub fn new_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        formula: &str,
+    ) -> Result<(), String> {
+        if !is_valid_identifier(name) {
+            return Err("Invalid defined name".to_string());
+        };
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        // if the defined name already exist return error
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                return Err("Defined name already exists".to_string());
+            }
+        }
+        self.workbook.defined_names.push(DefinedName {
+            name: name.to_string(),
+            formula: formula.to_string(),
+            sheet_id,
+        });
+        self.reset_parsed_structures();
+
+        Ok(())
+    }
+
+    /// Delete defined name of name and scope
+    pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        let mut index = None;
+        for (i, df) in defined_names.iter().enumerate() {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                index = Some(i);
+            }
+        }
+        if let Some(i) = index {
+            self.workbook.defined_names.remove(i);
+            self.reset_parsed_structures();
+            Ok(())
+        } else {
+            Err("Defined name not found".to_string())
+        }
+    }
+
+    /// Update defined name
+    pub fn update_defined_name(
+        &mut self,
+        name: &str,
+        scope: Option<u32>,
+        new_name: &str,
+        new_scope: Option<u32>,
+        new_formula: &str,
+    ) -> Result<(), String> {
+        if !is_valid_identifier(new_name) {
+            return Err("Invalid defined name".to_string());
+        };
+        let name_upper = name.to_uppercase();
+        let new_name_upper = new_name.to_uppercase();
+
+        if name_upper != new_name_upper || scope != new_scope {
+            for key in self.parsed_defined_names.keys() {
+                if key.1.to_uppercase() == new_name_upper && key.0 == new_scope {
+                    return Err("Defined name already exists".to_string());
+                }
+            }
+        }
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+
+        let new_sheet_id = match new_scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+
+        let mut index = None;
+        for (i, df) in defined_names.iter().enumerate() {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                index = Some(i);
+            }
+        }
+        if let Some(i) = index {
+            if let Some(df) = self.workbook.defined_names.get_mut(i) {
+                if new_name != df.name {
+                    // We need to rename the name in every formula:
+
+                    // Parse all formulas with the old name
+                    // All internal formulas are R1C1
+                    self.parser.set_lexer_mode(LexerMode::R1C1);
+                    let worksheets = &mut self.workbook.worksheets;
+                    for worksheet in worksheets {
+                        let cell_reference = CellReferenceRC {
+                            sheet: worksheet.get_name(),
+                            row: 1,
+                            column: 1,
+                        };
+                        let mut formulas = Vec::new();
+                        for formula in &worksheet.shared_formulas {
+                            let mut t = self.parser.parse(formula, &cell_reference);
+                            rename_defined_name_in_node(&mut t, name, scope, new_name);
+                            formulas.push(to_rc_format(&t));
+                        }
+                        worksheet.shared_formulas = formulas;
+                    }
+                    // Se the mode back to A1
+                    self.parser.set_lexer_mode(LexerMode::A1);
+                }
+                df.name = new_name.to_string();
+                df.sheet_id = new_sheet_id;
+                df.formula = new_formula.to_string();
+                self.reset_parsed_structures();
+            }
+            Ok(())
+        } else {
+            Err("Defined name not found".to_string())
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::expect_used)]
     use super::CellReferenceIndex as CellReference;
     use crate::{test::util::new_empty_model, types::Cell};
 

base/src/new_empty.rs

@@ -4,6 +4,7 @@ use std::collections::HashMap;
 
 use crate::{
     calc_result::Range,
+    constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
     expressions::{
         lexer::LexerMode,
         parser::{
@@ -84,14 +85,14 @@ impl Model {
         let worksheets = &self.workbook.worksheets;
         for worksheet in worksheets {
             let shared_formulas = &worksheet.shared_formulas;
-            let cell_reference = &Some(CellReferenceRC {
+            let cell_reference = CellReferenceRC {
                 sheet: worksheet.get_name(),
                 row: 1,
                 column: 1,
-            });
+            };
             let mut parse_formula = Vec::new();
             for formula in shared_formulas {
-                let t = self.parser.parse(formula, cell_reference);
+                let t = self.parser.parse(formula, &cell_reference);
                 parse_formula.push(t);
             }
             self.parsed_formulas.push(parse_formula);
@@ -143,8 +144,14 @@ impl Model {
 
     /// Reparses all formulas and defined names
     pub(crate) fn reset_parsed_structures(&mut self) {
+        let defined_names = self
+            .workbook
+            .get_defined_names_with_scope()
+            .iter()
+            .map(|s| (s.0.to_owned(), s.1))
+            .collect();
         self.parser
-            .set_worksheets(self.workbook.get_worksheet_names());
+            .set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
         self.parsed_formulas = vec![];
         self.parse_formulas();
         self.parsed_defined_names = HashMap::new();
@@ -261,11 +268,11 @@ impl Model {
         // We use iter because the default would be a mut_iter and we don't need a mutable reference
         let worksheets = &mut self.workbook.worksheets;
         for worksheet in worksheets {
-            let cell_reference = &Some(CellReferenceRC {
+            let cell_reference = &CellReferenceRC {
                 sheet: worksheet.get_name(),
                 row: 1,
                 column: 1,
-            });
+            };
             let mut formulas = Vec::new();
             for formula in &worksheet.shared_formulas {
                 let mut t = self.parser.parse(formula, cell_reference);
@@ -353,7 +360,14 @@ impl Model {
         let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
 
         let mut views = HashMap::new();
-        views.insert(0, WorkbookView { sheet: 0 });
+        views.insert(
+            0,
+            WorkbookView {
+                sheet: 0,
+                window_width: DEFAULT_WINDOW_WIDTH,
+                window_height: DEFAULT_WINDOW_HEIGHT,
+            },
+        );
 
         // String versions of the locale are added here to simplify the serialize/deserialize logic
         let workbook = Workbook {
@@ -380,10 +394,11 @@ impl Model {
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
         let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
-        let parser = Parser::new(worksheet_names, HashMap::new());
+        let parser = Parser::new(worksheet_names, vec![], HashMap::new());
         let cells = HashMap::new();
 
         // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("").clone();
 
         let mut model = Model {

base/src/styles.rs

@@ -161,26 +161,29 @@ impl Styles {
 
     pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
         let style_index = self.create_new_style(style);
-        self.add_named_cell_style(style_name, style_index)?;
+        self.add_named_cell_style(style_name, style_index)
-        Ok(())
     }
 
-    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> i32 {
+    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
-        let mut style = self.get_style(index);
+        let mut style = self.get_style(index)?;
         style.quote_prefix = true;
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
     }
 
-    pub(crate) fn get_style_with_format(&mut self, index: i32, num_fmt: &str) -> i32 {
+    pub(crate) fn get_style_with_format(
-        let mut style = self.get_style(index);
+        &mut self,
+        index: i32,
+        num_fmt: &str,
+    ) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
         style.num_fmt = num_fmt.to_string();
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
     }
 
-    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> i32 {
+    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
-        let mut style = self.get_style(index);
+        let mut style = self.get_style(index)?;
         style.quote_prefix = false;
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
     }
 
     pub(crate) fn style_is_quote_prefix(&self, index: i32) -> bool {
@@ -188,9 +191,11 @@ impl Styles {
         cell_xf.quote_prefix
     }
 
-    pub(crate) fn get_style(&self, index: i32) -> Style {
+    pub(crate) fn get_style(&self, index: i32) -> Result<Style, String> {
-        let cell_xf = &self.cell_xfs[index as usize];
+        let cell_xf = &self
-
+            .cell_xfs
+            .get(index as usize)
+            .ok_or("Invalid index provided".to_string())?;
         let border_id = cell_xf.border_id as usize;
         let fill_id = cell_xf.fill_id as usize;
         let font_id = cell_xf.font_id as usize;
@@ -198,14 +203,14 @@ impl Styles {
         let quote_prefix = cell_xf.quote_prefix;
         let alignment = cell_xf.alignment.clone();
 
-        Style {
+        Ok(Style {
             alignment,
             num_fmt: get_num_fmt(num_fmt_id, &self.num_fmts),
             fill: self.fills[fill_id].clone(),
             font: self.fonts[font_id].clone(),
             border: self.borders[border_id].clone(),
             quote_prefix,
-        }
+        })
     }
 }
 
@@ -221,8 +226,7 @@ impl Model {
         let style_index = self.workbook.styles.get_style_index_or_create(style);
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
+            .set_cell_style(row, column, style_index)
-        Ok(())
     }
 
     pub fn copy_cell_style(
@@ -237,9 +241,7 @@ impl Model {
 
         self.workbook
             .worksheet_mut(destination_cell.0)?
-            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index);
+            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index)
-
-        Ok(())
     }
 
     /// Sets the style "style_name" in cell
@@ -253,8 +255,7 @@ impl Model {
         let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
+            .set_cell_style(row, column, style_index)
-        Ok(())
     }
 
     pub fn set_sheet_style(&mut self, sheet: u32, style_name: &str) -> Result<(), String> {

base/src/test/mod.rs

@@ -15,15 +15,18 @@ mod test_fn_concatenate;
 mod test_fn_count;
 mod test_fn_exact;
 mod test_fn_financial;
+mod test_fn_formulatext;
 mod test_fn_if;
 mod test_fn_maxifs;
 mod test_fn_minifs;
+mod test_fn_or_xor;
 mod test_fn_product;
 mod test_fn_rept;
 mod test_fn_sum;
 mod test_fn_sumifs;
 mod test_fn_textbefore;
 mod test_fn_textjoin;
+mod test_fn_unicode;
 mod test_forward_references;
 mod test_frozen_rows_columns;
 mod test_general;
@@ -48,10 +51,14 @@ mod test_number_format;
 
 mod test_escape_quotes;
 mod test_extend;
+mod test_fn_fv;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
+mod test_geomean;
 mod test_get_cell_content;
+mod test_issue_155;
 mod test_percentage;
+mod test_set_functions_error_handling;
 mod test_today;
 mod test_types;
 mod user_model;

base/src/test/test_actions.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::constants::LAST_COLUMN;
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -87,7 +87,8 @@ fn test_insert_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -106,7 +107,8 @@ fn test_insert_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
 
     // Row 10 is now row 15
@@ -120,7 +122,8 @@ fn test_delete_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -139,7 +142,8 @@ fn test_delete_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
 
     // Row 10 is now row 5

base/src/test/test_column_width.rs

@@ -26,7 +26,7 @@ fn test_column_width() {
     assert!((worksheet.get_column_width(1).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
     assert!((worksheet.get_column_width(2).unwrap() - 30.0).abs() < f64::EPSILON);
     assert!((worksheet.get_column_width(3).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 2), 6);
+    assert_eq!(model.get_cell_style_index(0, 23, 2), Ok(6));
 }
 
 #[test]
@@ -53,7 +53,7 @@ fn test_column_width_lower_edge() {
     assert!(
         (worksheet.get_column_width(6).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
     );
-    assert_eq!(model.get_cell_style_index(0, 23, 5), 1);
+    assert_eq!(model.get_cell_style_index(0, 23, 5), Ok(1));
 }
 
 #[test]
@@ -80,5 +80,23 @@ fn test_column_width_higher_edge() {
     );
     assert!((worksheet.get_column_width(16).unwrap() - 30.0).abs() < f64::EPSILON);
     assert!((worksheet.get_column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 16), 1);
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(1));
+}
+
+#[test]
+fn test_column_width_negative() {
+    let mut model = new_empty_model();
+    let result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_column_width(16, -1.0);
+    assert_eq!(result, Err("Can not set a negative width: -1".to_string()));
+    assert_eq!(model.workbook.worksheets[0].cols.len(), 0);
+    let worksheet = model.workbook.worksheet(0).unwrap();
+    assert_eq!(
+        (worksheet.get_column_width(16).unwrap()),
+        DEFAULT_COLUMN_WIDTH
+    );
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(0));
 }

base/src/test/test_error_propagation.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::panic)]
 
 use crate::test::util::new_empty_model;
 use crate::types::Cell;

base/src/test/test_fn_formulatext.rs

@@ -0,0 +1,44 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn wrong_number_of_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT()");
+    model._set("A2", "=FORMULATEXT(\"B\",\"A\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}
+
+#[test]
+fn multi_sheet_ref() {
+    let mut model = new_empty_model();
+    model.new_sheet();
+    model._set("A1", "=FORMULATEXT(Sheet1!A1:Sheet2!A1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn implicit_intersection() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT(C1:C2)");
+    model._set("A2", "=FORMULATEXT(D1:E1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}
+
+#[test]
+fn non_reference() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT(42)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}

base/src/test/test_fn_fv.rs

@@ -0,0 +1,36 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn computation() {
+    let i2 = "=-C2*(1+D2)^E2-F2*((D2+1)*((1+D2)^E2-1))/D2";
+
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", i2);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-183");
+    assert_eq!(model._get_formula("I2"), i2);
+}
+
+#[test]
+fn format_as_currency() {
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", "=FV(D2,E2,F2,C2,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-$183.00");
+}

base/src/test/test_fn_or_xor.rs

@@ -0,0 +1,204 @@
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::print_stdout)]
+use crate::test::util::new_empty_model;
+
+// These tests are grouped because in many cases XOR and OR have similar behaviour.
+
+// Test specific to xor
+#[test]
+fn fn_xor() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=XOR(1, 1, 1, 0, 0)");
+    model._set("A2", "=XOR(1, 1, 0, 0, 0)");
+    model._set("A3", "=XOR(TRUE, TRUE, TRUE, FALSE, FALSE)");
+    model._set("A4", "=XOR(TRUE, TRUE, FALSE, FALSE, FALSE)");
+    model._set("A5", "=XOR(FALSE, FALSE, FALSE, FALSE, FALSE)");
+    model._set("A6", "=XOR(TRUE, TRUE)");
+    model._set("A7", "=XOR(0,0,0)");
+    model._set("A8", "=XOR(0,0,1)");
+    model._set("A9", "=XOR(0,1,0)");
+    model._set("A10", "=XOR(0,1,1)");
+    model._set("A11", "=XOR(1,0,0)");
+    model._set("A12", "=XOR(1,0,1)");
+    model._set("A13", "=XOR(1,1,0)");
+    model._set("A14", "=XOR(1,1,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"FALSE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"FALSE");
+    assert_eq!(model._get_text("A5"), *"FALSE");
+    assert_eq!(model._get_text("A6"), *"FALSE");
+    assert_eq!(model._get_text("A7"), *"FALSE");
+    assert_eq!(model._get_text("A8"), *"TRUE");
+    assert_eq!(model._get_text("A9"), *"TRUE");
+    assert_eq!(model._get_text("A10"), *"FALSE");
+    assert_eq!(model._get_text("A11"), *"TRUE");
+    assert_eq!(model._get_text("A12"), *"FALSE");
+    assert_eq!(model._get_text("A13"), *"FALSE");
+    assert_eq!(model._get_text("A14"), *"TRUE");
+}
+
+#[test]
+fn fn_or() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=OR(1, 1, 1, 0, 0)");
+    model._set("A2", "=OR(1, 1, 0, 0, 0)");
+    model._set("A3", "=OR(TRUE, TRUE, TRUE, FALSE, FALSE)");
+    model._set("A4", "=OR(TRUE, TRUE, FALSE, FALSE, FALSE)");
+    model._set("A5", "=OR(FALSE, FALSE, FALSE, FALSE, FALSE)");
+    model._set("A6", "=OR(TRUE, TRUE)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"TRUE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"TRUE");
+    assert_eq!(model._get_text("A5"), *"FALSE");
+    assert_eq!(model._get_text("A6"), *"TRUE");
+}
+
+#[test]
+fn fn_or_xor() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+
+        // Text args
+        model._set("A1", &format!(r#"={func}("")"#));
+        model._set("A2", &format!(r#"={func}("", "")"#));
+        model._set("A3", &format!(r#"={func}("", TRUE)"#));
+        model._set("A4", &format!(r#"={func}("", FALSE)"#));
+
+        model._set("A5", &format!("={func}(FALSE, TRUE)"));
+        model._set("A6", &format!("={func}(FALSE, FALSE)"));
+        model._set("A7", &format!("={func}(TRUE, FALSE)"));
+
+        // Reference to empty cell, plus true argument
+        model._set("A8", &format!("={func}(Z99, 1)"));
+
+        // Reference to empty cell/range
+        model._set("A9", &format!("={func}(Z99)"));
+        model._set("A10", &format!("={func}(X99:Z99"));
+
+        // Reference to cell with reference to empty range
+        model._set("B11", "=X99:Z99");
+        model._set("A11", &format!("={func}(B11)"));
+
+        // Reference to cell with non-empty range
+        model._set("X12", "1");
+        model._set("B12", "=X12:Z12");
+        model._set("A12", &format!("={func}(B12)"));
+
+        // Reference to text cell
+        model._set("B13", "some_text");
+        model._set("A13", &format!("={func}(B13)"));
+        model._set("A14", &format!("={func}(B13, 0)"));
+        model._set("A15", &format!("={func}(B13, 1)"));
+
+        // Reference to Implicit intersection
+        model._set("X16", "1");
+        model._set("B16", "=@X15:X16");
+        model._set("A16", &format!("={func}(B16)"));
+
+        // Non-empty range
+        model._set("B17", "1");
+        model._set("A17", &format!("={func}(B17:C17)"));
+
+        // Non-empty range with text
+        model._set("B18", "text");
+        model._set("A18", &format!("={func}(B18:C18)"));
+
+        // Non-empty range with text and number
+        model._set("B19", "text");
+        model._set("C19", "1");
+        model._set("A19", &format!("={func}(B19:C19)"));
+
+        // range with error
+        model._set("B20", "=1/0");
+        model._set("A20", &format!("={func}(B20:C20)"));
+
+        model.evaluate();
+
+        assert_eq!(model._get_text("A1"), *"#VALUE!");
+        assert_eq!(model._get_text("A2"), *"#VALUE!");
+        assert_eq!(model._get_text("A3"), *"TRUE");
+        assert_eq!(model._get_text("A4"), *"FALSE");
+
+        assert_eq!(model._get_text("A5"), *"TRUE");
+        assert_eq!(model._get_text("A6"), *"FALSE");
+        assert_eq!(model._get_text("A7"), *"TRUE");
+
+        assert_eq!(model._get_text("A8"), *"TRUE");
+
+        assert_eq!(model._get_text("A9"), *"#VALUE!");
+        assert_eq!(model._get_text("A10"), *"#VALUE!");
+
+        assert_eq!(model._get_text("A11"), *"#VALUE!");
+
+        // TODO: This one depends on spill behaviour which isn't implemented yet
+        // assert_eq!(model._get_text("A12"), *"TRUE");
+
+        assert_eq!(model._get_text("A13"), *"#VALUE!");
+        assert_eq!(model._get_text("A14"), *"FALSE");
+        assert_eq!(model._get_text("A15"), *"TRUE");
+
+        // TODO: This one depends on @ implicit intersection behaviour which isn't implemented yet
+        // assert_eq!(model._get_text("A16"), *"TRUE");
+
+        assert_eq!(model._get_text("A17"), *"TRUE");
+
+        assert_eq!(model._get_text("A18"), *"#VALUE!");
+
+        assert_eq!(model._get_text("A19"), *"TRUE");
+
+        assert_eq!(model._get_text("A20"), *"#DIV/0!");
+    }
+}
+
+#[test]
+fn fn_or_xor_no_arguments() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+        model._set("A1", &format!("={}()", func));
+        model.evaluate();
+        assert_eq!(model._get_text("A1"), *"#ERROR!");
+    }
+}
+
+#[test]
+fn fn_or_xor_missing_arguments() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+        model._set("A1", &format!("={func}(,)"));
+        model._set("A2", &format!("={func}(,1)"));
+        model._set("A3", &format!("={func}(1,)"));
+        model._set("A4", &format!("={func}(,B1)"));
+        model._set("A5", &format!("={func}(,B1:B4)"));
+        model.evaluate();
+        assert_eq!(model._get_text("A1"), *"FALSE");
+        assert_eq!(model._get_text("A2"), *"TRUE");
+        assert_eq!(model._get_text("A3"), *"TRUE");
+        assert_eq!(model._get_text("A4"), *"FALSE");
+        assert_eq!(model._get_text("A5"), *"FALSE");
+    }
+}

base/src/test/test_fn_unicode.rs

@@ -0,0 +1,63 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_cases() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE(\"1,00\")");
+    model._set("A2", "=UNICODE(\"1\")");
+    model._set("A3", "=UNICODE(1)");
+    model._set("A4", "=UNICODE(\"T\")");
+    model._set("A5", "=UNICODE(\"TRUE\")");
+    model._set("A6", "=UNICODE(TRUE)");
+    model._set("A7", "=UNICODE(FALSE)");
+    model._set("A8", "=UNICODE(\"の\")");
+    model._set("A9", "=UNICODE(\" \")");
+
+    model._set("A10", "=_xlfn.UNICODE(\"T\")");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"49");
+    assert_eq!(model._get_text("A2"), *"49");
+    assert_eq!(model._get_text("A3"), *"49");
+    assert_eq!(model._get_text("A4"), *"84");
+    assert_eq!(model._get_text("A5"), *"84");
+    assert_eq!(model._get_text("A6"), *"84");
+    assert_eq!(model._get_text("A7"), *"70");
+    assert_eq!(model._get_text("A8"), *"12398");
+    assert_eq!(model._get_text("A9"), *"32");
+    assert_eq!(model._get_text("A10"), *"84");
+}
+
+#[test]
+fn test_error_cases() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE(\"\")");
+    model._set("A2", "=UNICODE(#CALC!)");
+    model._set("A3", "=UNICODE(#NAME?)");
+    model._set("A4", "=UNICODE(#VALUE!)");
+    model._set("A5", "=UNICODE(#REF!)");
+    model._set("A6", "=UNICODE(#DIV/0!)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#VALUE!");
+    assert_eq!(model._get_text("A2"), *"#CALC!");
+    assert_eq!(model._get_text("A3"), *"#NAME?");
+    assert_eq!(model._get_text("A4"), *"#VALUE!");
+    assert_eq!(model._get_text("A5"), *"#REF!");
+    assert_eq!(model._get_text("A6"), *"#DIV/0!");
+}
+
+#[test]
+fn wrong_number_of_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE()");
+    model._set("A2", "=UNICODE(\"B\",\"A\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}

base/src/test/test_general.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
+use crate::constants::DEFAULT_ROW_HEIGHT;
+
 use crate::cell::CellValue;
 
 use crate::number_format::to_excel_precision_str;
@@ -17,7 +19,9 @@ fn test_empty_model() {
 #[test]
 fn test_model_simple_evaluation() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "= 1 + 3".to_string());
+    model
+        .set_user_input(0, 1, 1, "= 1 + 3".to_string())
+        .unwrap();
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"4");
@@ -43,7 +47,7 @@ fn test_model_simple_evaluation_order() {
 #[test]
 fn test_model_invalid_formula() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "= 1 +".to_string());
+    model.set_user_input(0, 1, 1, "= 1 +".to_string()).unwrap();
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"#ERROR!");
@@ -54,8 +58,10 @@ fn test_model_invalid_formula() {
 #[test]
 fn test_model_dependencies() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "23".to_string()); // A1
+    model.set_user_input(0, 1, 1, "23".to_string()).unwrap(); // A1
-    model.set_user_input(0, 1, 2, "= A1* 2-4".to_string()); // B1
+    model
+        .set_user_input(0, 1, 2, "= A1* 2-4".to_string())
+        .unwrap(); // B1
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"23");
@@ -65,7 +71,9 @@ fn test_model_dependencies() {
     let result = model._get_formula("B1");
     assert_eq!(result, *"=A1*2-4");
 
-    model.set_user_input(0, 2, 1, "=SUM(A1, B1)".to_string()); // A2
+    model
+        .set_user_input(0, 2, 1, "=SUM(A1, B1)".to_string())
+        .unwrap(); // A2
     model.evaluate();
     let result = model._get_text_at(0, 2, 1);
     assert_eq!(result, *"65");
@@ -74,8 +82,10 @@ fn test_model_dependencies() {
 #[test]
 fn test_model_strings() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "Hello World".to_string());
+    model
-    model.set_user_input(0, 1, 2, "=A1".to_string());
+        .set_user_input(0, 1, 1, "Hello World".to_string())
+        .unwrap();
+    model.set_user_input(0, 1, 2, "=A1".to_string()).unwrap();
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"Hello World");
@@ -105,6 +115,15 @@ fn test_set_row_height() {
     worksheet.set_row_height(5, 5.0).unwrap();
     let worksheet = model.workbook.worksheet(0).unwrap();
     assert!((5.0 - worksheet.row_height(5).unwrap()).abs() < f64::EPSILON);
+
+    let worksheet = model.workbook.worksheet_mut(0).unwrap();
+    let result = worksheet.set_row_height(6, -1.0);
+    assert_eq!(result, Err("Can not set a negative height: -1".to_string()));
+
+    assert_eq!(worksheet.row_height(6).unwrap(), DEFAULT_ROW_HEIGHT);
+
+    worksheet.set_row_height(6, 0.0).unwrap();
+    assert_eq!(worksheet.row_height(6).unwrap(), 0.0);
 }
 
 #[test]
@@ -152,21 +171,35 @@ fn test_to_excel_precision_str() {
 #[test]
 fn test_booleans() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "true".to_string());
+    model.set_user_input(0, 1, 1, "true".to_string()).unwrap();
-    model.set_user_input(0, 2, 1, "TRUE".to_string());
+    model.set_user_input(0, 2, 1, "TRUE".to_string()).unwrap();
-    model.set_user_input(0, 3, 1, "True".to_string());
+    model.set_user_input(0, 3, 1, "True".to_string()).unwrap();
-    model.set_user_input(0, 4, 1, "false".to_string());
+    model.set_user_input(0, 4, 1, "false".to_string()).unwrap();
-    model.set_user_input(0, 5, 1, "FALSE".to_string());
+    model.set_user_input(0, 5, 1, "FALSE".to_string()).unwrap();
-    model.set_user_input(0, 6, 1, "False".to_string());
+    model.set_user_input(0, 6, 1, "False".to_string()).unwrap();
 
-    model.set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string());
+    model
-    model.set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string());
+        .set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string())
-    model.set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string());
+        .unwrap();
-    model.set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string());
+    model
-    model.set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string());
+        .set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string())
-    model.set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string());
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string())
+        .unwrap();
 
-    model.set_user_input(0, 1, 5, "=IF(false, True, FALSe)".to_string());
+    model
+        .set_user_input(0, 1, 5, "=IF(false, True, FALSe)".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -191,19 +224,19 @@ fn test_booleans() {
 #[test]
 fn test_set_cell_style() {
     let mut model = new_empty_model();
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(!style.font.b);
 
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
 
     style.font.b = false;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(!style.font.b);
 }
 
@@ -211,21 +244,21 @@ fn test_set_cell_style() {
 fn test_copy_cell_style() {
     let mut model = new_empty_model();
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let mut style = model.get_style_for_cell(0, 1, 2);
+    let mut style = model.get_style_for_cell(0, 1, 2).unwrap();
     style.font.i = true;
     assert!(model.set_cell_style(0, 1, 2, &style).is_ok());
 
     assert!(model.copy_cell_style((0, 1, 1), (0, 1, 2)).is_ok());
 
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
     assert!(!style.font.i);
 
-    let style = model.get_style_for_cell(0, 1, 2);
+    let style = model.get_style_for_cell(0, 1, 2).unwrap();
     assert!(style.font.b);
     assert!(!style.font.i);
 }
@@ -234,15 +267,15 @@ fn test_copy_cell_style() {
 fn test_get_cell_style_index() {
     let mut model = new_empty_model();
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 0);
     assert!(!style.font.b);
 
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 1);
 }
 
@@ -250,29 +283,29 @@ fn test_get_cell_style_index() {
 fn test_model_set_cells_with_values_styles() {
     let mut model = new_empty_model();
     // Inputs
-    model.set_user_input(0, 1, 1, "21".to_string()); // A1
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
-    model.set_user_input(0, 2, 1, "2".to_string()); // A2
+    model.set_user_input(0, 2, 1, "2".to_string()).unwrap(); // A2
 
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 0);
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
     assert!(model.set_cell_style(0, 2, 1, &style).is_ok());
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 1);
-    let style_index = model.get_cell_style_index(0, 2, 1);
+    let style_index = model.get_cell_style_index(0, 2, 1).unwrap();
     assert_eq!(style_index, 1);
 
-    model.update_cell_with_number(0, 1, 2, 1.0);
+    model.update_cell_with_number(0, 1, 2, 1.0).unwrap();
-    model.update_cell_with_number(0, 2, 1, 2.0);
+    model.update_cell_with_number(0, 2, 1, 2.0).unwrap();
 
     model.evaluate();
 
     // Styles are not modified
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 1);
-    let style_index = model.get_cell_style_index(0, 2, 1);
+    let style_index = model.get_cell_style_index(0, 2, 1).unwrap();
     assert_eq!(style_index, 1);
 }
 
@@ -280,20 +313,20 @@ fn test_model_set_cells_with_values_styles() {
 fn test_style_fmt_id() {
     let mut model = new_empty_model();
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.num_fmt = "#.##".to_string();
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert_eq!(style.num_fmt, "#.##");
 
-    let mut style = model.get_style_for_cell(0, 10, 1);
+    let mut style = model.get_style_for_cell(0, 10, 1).unwrap();
     style.num_fmt = "$$#,##0.0000".to_string();
     assert!(model.set_cell_style(0, 10, 1, &style).is_ok());
-    let style = model.get_style_for_cell(0, 10, 1);
+    let style = model.get_style_for_cell(0, 10, 1).unwrap();
     assert_eq!(style.num_fmt, "$$#,##0.0000");
 
     // Make sure old style is not touched
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert_eq!(style.num_fmt, "#.##");
 }
 
@@ -357,9 +390,13 @@ fn set_input_autocomplete() {
     let mut model = new_empty_model();
     model._set("A1", "1");
     model._set("A2", "2");
-    model.set_user_input(0, 3, 1, "=SUM(A1:A2".to_string());
+    model
+        .set_user_input(0, 3, 1, "=SUM(A1:A2".to_string())
+        .unwrap();
     // This will fail anyway
-    model.set_user_input(0, 4, 1, "=SUM(A1*".to_string());
+    model
+        .set_user_input(0, 4, 1, "=SUM(A1*".to_string())
+        .unwrap();
     model.evaluate();
 
     assert_eq!(model._get_formula("A3"), "=SUM(A1:A2)");
@@ -405,7 +442,7 @@ fn test_get_formatted_cell_value() {
     model._set("A5", "123.456");
 
     // change A5 format
-    let mut style = model.get_style_for_cell(0, 5, 1);
+    let mut style = model.get_style_for_cell(0, 5, 1).unwrap();
     style.num_fmt = "$#,##0.00".to_string();
     model.set_cell_style(0, 5, 1, &style).unwrap();
 

base/src/test/test_geomean.rs

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_fn_geomean_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=GEOMEAN()");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn test_fn_geomean_minimal() {
+    let mut model = new_empty_model();
+    model._set("B1", "1");
+    model._set("B2", "2");
+    model._set("B3", "3");
+    model._set("B4", "'2");
+    // B5 is empty
+    model._set("B6", "true");
+    model._set("A1", "=GEOMEAN(B1:B6)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1.817120593");
+}

base/src/test/test_get_cell_content.rs

@@ -5,8 +5,12 @@ use crate::test::util::new_empty_model;
 #[test]
 fn test_formulas() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "$100.348".to_string());
+    model
-    model.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+        .set_user_input(0, 1, 1, "$100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string())
+        .unwrap();
 
     model.evaluate();
 

base/src/test/test_issue_155.rs

@@ -0,0 +1,14 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn issue_155() {
+    let mut model = new_empty_model();
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("B2", "=A$1:A2");
+    model.evaluate();
+
+    assert_eq!(model._get_formula("B2"), "=A$1:A2".to_string());
+}

base/src/test/test_metadata.rs

@@ -1,9 +1,11 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::test::util::new_empty_model;
 
 #[test]
 fn test_metadata_new_model() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "5.5".to_string());
+    model.set_user_input(0, 1, 1, "5.5".to_string()).unwrap();
     model.evaluate();
     let metadata = &model.workbook.metadata;
     assert_eq!(metadata.application, "IronCalc Sheets");

base/src/test/test_model_is_empty_cell.rs

@@ -14,7 +14,9 @@ fn test_is_empty_cell_non_existing_sheet() {
 fn test_is_empty_cell() {
     let mut model = new_empty_model();
     assert!(model.is_empty_cell(0, 3, 1).unwrap());
-    model.set_user_input(0, 3, 1, "Hello World".to_string());
+    model
+        .set_user_input(0, 3, 1, "Hello World".to_string())
+        .unwrap();
     assert!(!model.is_empty_cell(0, 3, 1).unwrap());
     model.cell_clear_contents(0, 3, 1).unwrap();
     assert!(model.is_empty_cell(0, 3, 1).unwrap());

base/src/test/test_quote_prefix.rs

@@ -57,12 +57,12 @@ fn test_quote_prefix_enter() {
     model._set("A2", "=ISTEXT(A1)");
     model.evaluate();
     // We introduce a value with a "quote prefix" index
-    model.set_user_input(0, 1, 3, "'=A1".to_string());
+    model.set_user_input(0, 1, 3, "'=A1".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("C1"), *"=A1");
 
     // But if we enter with a quote_prefix but without the "'" it won't be quote_prefix
-    model.set_user_input(0, 1, 4, "=A1".to_string());
+    model.set_user_input(0, 1, 4, "=A1".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("D1"), *"123");
 }
@@ -75,7 +75,7 @@ fn test_quote_prefix_reenter() {
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
     // We introduce a value with a "quote prefix" index
-    model.set_user_input(0, 1, 1, "123".to_string());
+    model.set_user_input(0, 1, 1, "123".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"FALSE");
 }
@@ -83,7 +83,7 @@ fn test_quote_prefix_reenter() {
 #[test]
 fn test_update_cell_quote() {
     let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "= 1 + 3");
+    model.update_cell_with_text(0, 1, 1, "= 1 + 3").unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A1"), *"= 1 + 3");
     assert!(!model._has_formula("A1"));
@@ -92,12 +92,12 @@ fn test_update_cell_quote() {
 #[test]
 fn test_update_quote_prefix_reenter() {
     let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "123");
+    model.update_cell_with_text(0, 1, 1, "123").unwrap();
     model._set("A2", "=ISTEXT(A1)");
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
     // We reenter as a number
-    model.update_cell_with_number(0, 1, 1, 123.0);
+    model.update_cell_with_number(0, 1, 1, 123.0).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"FALSE");
 }
@@ -105,12 +105,12 @@ fn test_update_quote_prefix_reenter() {
 #[test]
 fn test_update_quote_prefix_reenter_bool() {
     let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "TRUE");
+    model.update_cell_with_text(0, 1, 1, "TRUE").unwrap();
     model._set("A2", "=ISTEXT(A1)");
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
     // We enter a bool
-    model.update_cell_with_bool(0, 1, 1, true);
+    model.update_cell_with_bool(0, 1, 1, true).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"FALSE");
 }
@@ -118,29 +118,29 @@ fn test_update_quote_prefix_reenter_bool() {
 #[test]
 fn test_update_quote_prefix_reenter_text() {
     let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "123");
+    model.update_cell_with_text(0, 1, 1, "123").unwrap();
     model._set("A2", "=ISTEXT(A1)");
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
     // We enter a string
-    model.update_cell_with_text(0, 1, 1, "Hello");
+    model.update_cell_with_text(0, 1, 1, "Hello").unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(!model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(!model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
 }
 
 #[test]
 fn test_update_quote_prefix_reenter_text_2() {
     let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "123");
+    model.update_cell_with_text(0, 1, 1, "123").unwrap();
     model._set("A2", "=ISTEXT(A1)");
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
     // We enter another number
-    model.update_cell_with_text(0, 1, 1, "42");
+    model.update_cell_with_text(0, 1, 1, "42").unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
 }

base/src/test/test_set_functions_error_handling.rs

@@ -0,0 +1,451 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::token, test::util::new_empty_model, types::Cell};
+
+#[test]
+fn test_update_cell_with_text() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.set_user_input(0, 1, 1, "Hello".to_string()).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_text(1, 1, 1, "new value");
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_text(0, 0, 1, "new value");
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_text(0, 1, 1048579, "new value");
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_number() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_number(1, 1, 1, 20.0);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_number(0, 0, 1, 20.0);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_number(0, 1, 1048579, 20.0);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_bool() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_bool(0, 1, 1, true).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_bool(1, 1, 1, false);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_bool(0, 0, 1, false);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_bool(0, 1, 1048579, false);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_formula() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model
+        .update_cell_with_formula(0, 1, 2, "=A1*2".to_string())
+        .unwrap();
+
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_formula(1, 1, 2, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_formula(0, 0, 2, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_formula(0, 1, 1048579, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_set_user_input() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.set_user_input(1, 1, 2, "20.0".to_string());
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.set_user_input(0, 0, 2, "20.0".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.set_user_input(0, 1, 1048579, "20.0".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_get_style_for_cell() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.get_style_for_cell(1, 1, 2);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // ATTENTION : get_cell_style_index tries to get cell using row and col
+    // if we invalid row or column is given, it will return index 0.
+
+    // Case2 : Invalid Row
+    let update_result = model.get_style_for_cell(0, 0, 2);
+    assert!(update_result.is_ok());
+
+    // Case3 : Invalid Column
+    let update_result = model.get_style_for_cell(0, 1, 1048579);
+    assert!(update_result.is_ok());
+}
+
+#[test]
+fn test_get_cell_style_index() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.get_cell_style_index(1, 1, 2);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // ATTENTION : get_cell_style_index tries to get cell using row and col
+    // if we invalid row or column is given, it will return index 0.
+
+    // Case2 : Invalid Row
+    let update_result = model.get_cell_style_index(0, 0, 2);
+    assert_eq!(update_result, Ok(0));
+
+    // Case3 : Invalid Column
+    let update_result = model.get_cell_style_index(0, 1, 1048579);
+    assert_eq!(update_result, Ok(0));
+}
+
+#[test]
+fn test_worksheet_update_cell() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result =
+        model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .update_cell(0, 1, Cell::new_number(10.0, 1));
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result =
+        model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .update_cell(1, 1048579, Cell::new_number(10.0, 1));
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_style() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_style(0, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_style(1, 1048579, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_formula() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_formula(0, 1, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_formula(1, 1048579, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_number() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_number(0, 1, 1.0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_number(1, 1048579, 1.0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_string() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_string(0, 1, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_string(1, 1048579, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_boolean() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_boolean(0, 1, true, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_boolean(1, 1048579, true, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_error() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1: Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_error(0, 1, token::Error::ERROR, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_error(1, 1048579, token::Error::ERROR, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_cell_clear_contents() {
+    let mut model = new_empty_model();
+
+    model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .update_cell(1, 1, Cell::new_number(10.0, 1))
+        .unwrap();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(1, 1048579);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Valid case
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(1, 1);
+    assert_eq!(update_result, Ok(()))
+}
+
+#[test]
+fn test_worksheet_cell_clear_contents_with_style() {
+    let mut model = new_empty_model();
+
+    model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .update_cell(1, 1, Cell::new_number(10.0, 1))
+        .unwrap();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(0, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(1, 1048579, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Valid case
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(1, 1, 1);
+    assert_eq!(update_result, Ok(()))
+}
+
+#[test]
+fn workbook_styles_get_style_error_handling() {
+    let model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style(15),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_without_quote_prefix_error_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style_without_quote_prefix(15),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_with_format_error_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model
+            .workbook
+            .styles
+            .get_style_with_format(15, "dummy_num_format"),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_with_quote_prefix_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style_with_quote_prefix(15),
+        Err("Invalid index provided".to_string())
+    );
+}

base/src/test/test_set_user_input.rs

@@ -5,16 +5,28 @@ use crate::{cell::CellValue, test::util::new_empty_model};
 #[test]
 fn test_currencies() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "$100.348".to_string());
+    model
-    model.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+        .set_user_input(0, 1, 1, "$100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string())
+        .unwrap();
 
-    model.set_user_input(0, 2, 1, "$ 100.348".to_string());
+    model
-    model.set_user_input(0, 2, 2, "=ISNUMBER(A2)".to_string());
+        .set_user_input(0, 2, 1, "$ 100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=ISNUMBER(A2)".to_string())
+        .unwrap();
 
-    model.set_user_input(0, 3, 1, "100$".to_string());
+    model.set_user_input(0, 3, 1, "100$".to_string()).unwrap();
-    model.set_user_input(0, 3, 2, "=ISNUMBER(A3)".to_string());
+    model
+        .set_user_input(0, 3, 2, "=ISNUMBER(A3)".to_string())
+        .unwrap();
 
-    model.set_user_input(0, 4, 1, "3.1415926$".to_string());
+    model
+        .set_user_input(0, 4, 1, "3.1415926$".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -43,9 +55,9 @@ fn test_currencies() {
 #[test]
 fn scientific() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "3e-4".to_string());
+    model.set_user_input(0, 1, 1, "3e-4".to_string()).unwrap();
-    model.set_user_input(0, 2, 1, "5e-4$".to_string());
+    model.set_user_input(0, 2, 1, "5e-4$".to_string()).unwrap();
-    model.set_user_input(0, 3, 1, "6e-4%".to_string());
+    model.set_user_input(0, 3, 1, "6e-4%".to_string()).unwrap();
 
     model.evaluate();
 
@@ -61,9 +73,13 @@ fn scientific() {
 #[test]
 fn test_percentage() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 10, 1, "50%".to_string());
+    model.set_user_input(0, 10, 1, "50%".to_string()).unwrap();
-    model.set_user_input(0, 10, 2, "=ISNUMBER(A10)".to_string());
+    model
-    model.set_user_input(0, 11, 1, "55.759%".to_string());
+        .set_user_input(0, 10, 2, "=ISNUMBER(A10)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 11, 1, "55.759%".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -81,8 +97,8 @@ fn test_percentage_ops() {
     let mut model = new_empty_model();
     model._set("A1", "5%");
     model._set("A2", "20%");
-    model.set_user_input(0, 3, 1, "=A1+A2".to_string());
+    model.set_user_input(0, 3, 1, "=A1+A2".to_string()).unwrap();
-    model.set_user_input(0, 4, 1, "=A1*A2".to_string());
+    model.set_user_input(0, 4, 1, "=A1*A2".to_string()).unwrap();
 
     model.evaluate();
 
@@ -93,11 +109,19 @@ fn test_percentage_ops() {
 #[test]
 fn test_numbers() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "1,000,000".to_string());
+    model
+        .set_user_input(0, 1, 1, "1,000,000".to_string())
+        .unwrap();
 
-    model.set_user_input(0, 20, 1, "50,123.549".to_string());
+    model
-    model.set_user_input(0, 21, 1, "50,12.549".to_string());
+        .set_user_input(0, 20, 1, "50,123.549".to_string())
-    model.set_user_input(0, 22, 1, "1,234567".to_string());
+        .unwrap();
+    model
+        .set_user_input(0, 21, 1, "50,12.549".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 22, 1, "1,234567".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -131,7 +155,7 @@ fn test_numbers() {
 #[test]
 fn test_negative_numbers() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "-100".to_string());
+    model.set_user_input(0, 1, 1, "-100".to_string()).unwrap();
 
     model.evaluate();
 
@@ -144,15 +168,19 @@ fn test_negative_numbers() {
 #[test]
 fn test_negative_currencies() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "-$100".to_string());
+    model.set_user_input(0, 1, 1, "-$100".to_string()).unwrap();
-    model.set_user_input(0, 2, 1, "-$99.123".to_string());
+    model
+        .set_user_input(0, 2, 1, "-$99.123".to_string())
+        .unwrap();
     // This is valid!
-    model.set_user_input(0, 3, 1, "$-345".to_string());
+    model.set_user_input(0, 3, 1, "$-345".to_string()).unwrap();
 
-    model.set_user_input(0, 1, 2, "-200$".to_string());
+    model.set_user_input(0, 1, 2, "-200$".to_string()).unwrap();
-    model.set_user_input(0, 2, 2, "-92.689$".to_string());
+    model
+        .set_user_input(0, 2, 2, "-92.689$".to_string())
+        .unwrap();
     // This is valid!
-    model.set_user_input(0, 3, 2, "-22$".to_string());
+    model.set_user_input(0, 3, 2, "-22$".to_string()).unwrap();
 
     model.evaluate();
 
@@ -174,8 +202,10 @@ fn test_formulas() {
     let mut model = new_empty_model();
     model._set("A1", "$100");
     model._set("A2", "$200");
-    model.set_user_input(0, 3, 1, "=A1+A2".to_string());
+    model.set_user_input(0, 3, 1, "=A1+A2".to_string()).unwrap();
-    model.set_user_input(0, 4, 1, "=SUM(A1:A3)".to_string());
+    model
+        .set_user_input(0, 4, 1, "=SUM(A1:A3)".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -198,9 +228,9 @@ fn test_product() {
     model._set("A2", "$5");
     model._set("A3", "4");
 
-    model.set_user_input(0, 1, 2, "=A1*A2".to_string());
+    model.set_user_input(0, 1, 2, "=A1*A2".to_string()).unwrap();
-    model.set_user_input(0, 2, 2, "=A1*A3".to_string());
+    model.set_user_input(0, 2, 2, "=A1*A3".to_string()).unwrap();
-    model.set_user_input(0, 3, 2, "=A1*3".to_string());
+    model.set_user_input(0, 3, 2, "=A1*3".to_string()).unwrap();
 
     model.evaluate();
 
@@ -216,10 +246,12 @@ fn test_division() {
     model._set("A2", "$5");
     model._set("A3", "4");
 
-    model.set_user_input(0, 1, 2, "=A1/A2".to_string());
+    model.set_user_input(0, 1, 2, "=A1/A2".to_string()).unwrap();
-    model.set_user_input(0, 2, 2, "=A1/A3".to_string());
+    model.set_user_input(0, 2, 2, "=A1/A3".to_string()).unwrap();
-    model.set_user_input(0, 3, 2, "=A1/2".to_string());
+    model.set_user_input(0, 3, 2, "=A1/2".to_string()).unwrap();
-    model.set_user_input(0, 4, 2, "=100/A2".to_string());
+    model
+        .set_user_input(0, 4, 2, "=100/A2".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -235,54 +267,54 @@ fn test_some_complex_examples() {
     // $3.00 / 2 = $1.50
     model._set("A1", "$3.00");
     model._set("A2", "2");
-    model.set_user_input(0, 3, 1, "=A1/A2".to_string());
+    model.set_user_input(0, 3, 1, "=A1/A2".to_string()).unwrap();
 
     // $3 / 2 = $1
     model._set("B1", "$3");
     model._set("B2", "2");
-    model.set_user_input(0, 3, 2, "=B1/B2".to_string());
+    model.set_user_input(0, 3, 2, "=B1/B2".to_string()).unwrap();
 
     // $5.00 * 25% = 25% * $5.00 = $1.25
     model._set("C1", "$5.00");
     model._set("C2", "25%");
-    model.set_user_input(0, 3, 3, "=C1*C2".to_string());
+    model.set_user_input(0, 3, 3, "=C1*C2".to_string()).unwrap();
-    model.set_user_input(0, 4, 3, "=C2*C1".to_string());
+    model.set_user_input(0, 4, 3, "=C2*C1".to_string()).unwrap();
 
     // $5 * 75% = 75% * $5 = $1
     model._set("D1", "$5");
     model._set("D2", "75%");
-    model.set_user_input(0, 3, 4, "=D1*D2".to_string());
+    model.set_user_input(0, 3, 4, "=D1*D2".to_string()).unwrap();
-    model.set_user_input(0, 4, 4, "=D2*D1".to_string());
+    model.set_user_input(0, 4, 4, "=D2*D1".to_string()).unwrap();
 
     // $10 + $9.99 = $9.99 + $10 = $19.99
     model._set("E1", "$10");
     model._set("E2", "$9.99");
-    model.set_user_input(0, 3, 5, "=E1+E2".to_string());
+    model.set_user_input(0, 3, 5, "=E1+E2".to_string()).unwrap();
-    model.set_user_input(0, 4, 5, "=E2+E1".to_string());
+    model.set_user_input(0, 4, 5, "=E2+E1".to_string()).unwrap();
 
     // $2 * 2 = 2 * $2 = $4
     model._set("F1", "$2");
     model._set("F2", "2");
-    model.set_user_input(0, 3, 6, "=F1*F2".to_string());
+    model.set_user_input(0, 3, 6, "=F1*F2".to_string()).unwrap();
-    model.set_user_input(0, 4, 6, "=F2*F1".to_string());
+    model.set_user_input(0, 4, 6, "=F2*F1".to_string()).unwrap();
 
     // $2.50 * 2 = 2 * $2.50 = $5.00
     model._set("G1", "$2.50");
     model._set("G2", "2");
-    model.set_user_input(0, 3, 7, "=G1*G2".to_string());
+    model.set_user_input(0, 3, 7, "=G1*G2".to_string()).unwrap();
-    model.set_user_input(0, 4, 7, "=G2*G1".to_string());
+    model.set_user_input(0, 4, 7, "=G2*G1".to_string()).unwrap();
 
     // $2 * 2.5 = 2.5 * $2 = $5
     model._set("H1", "$2");
     model._set("H2", "2.5");
-    model.set_user_input(0, 3, 8, "=H1*H2".to_string());
+    model.set_user_input(0, 3, 8, "=H1*H2".to_string()).unwrap();
-    model.set_user_input(0, 4, 8, "=H2*H1".to_string());
+    model.set_user_input(0, 4, 8, "=H2*H1".to_string()).unwrap();
 
     // 10% * 1,000 = 1,000 * 10% = 100
     model._set("I1", "10%");
     model._set("I2", "1,000");
-    model.set_user_input(0, 3, 9, "=I1*I2".to_string());
+    model.set_user_input(0, 3, 9, "=I1*I2".to_string()).unwrap();
-    model.set_user_input(0, 4, 9, "=I2*I1".to_string());
+    model.set_user_input(0, 4, 9, "=I2*I1".to_string()).unwrap();
 
     model.evaluate();
 
@@ -320,9 +352,15 @@ fn test_financial_functions() {
     model._set("A3", "10");
     model._set("A4", "$10,000");
 
-    model.set_user_input(0, 5, 1, "=PMT(A2/12,A3,A4)".to_string());
+    model
-    model.set_user_input(0, 6, 1, "=PMT(A2/12,A3,A4,,1)".to_string());
+        .set_user_input(0, 5, 1, "=PMT(A2/12,A3,A4)".to_string())
-    model.set_user_input(0, 7, 1, "=PMT(0.2, 3, -200)".to_string());
+        .unwrap();
+    model
+        .set_user_input(0, 6, 1, "=PMT(A2/12,A3,A4,,1)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 7, 1, "=PMT(0.2, 3, -200)".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -339,9 +377,15 @@ fn test_sum_function() {
     model._set("A1", "$100");
     model._set("A2", "$300");
 
-    model.set_user_input(0, 1, 2, "=SUM(A:A)".to_string());
+    model
-    model.set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string());
+        .set_user_input(0, 1, 2, "=SUM(A:A)".to_string())
-    model.set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string());
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -353,7 +397,7 @@ fn test_sum_function() {
 #[test]
 fn test_number() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "3".to_string());
+    model.set_user_input(0, 1, 1, "3".to_string()).unwrap();
 
     model.evaluate();
 
@@ -367,7 +411,9 @@ fn test_number() {
 #[test]
 fn test_currencies_eur_prefix() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "€100.348".to_string());
+    model
+        .set_user_input(0, 1, 1, "€100.348".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -381,19 +427,27 @@ fn test_currencies_eur_prefix() {
 #[test]
 fn test_currencies_eur_suffix() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "100.348€".to_string());
+    model
-    model.set_user_input(0, 2, 1, "25€".to_string());
+        .set_user_input(0, 1, 1, "100.348€".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 1, "25€".to_string()).unwrap();
 
     // negatives
-    model.set_user_input(0, 1, 2, "-123.348€".to_string());
+    model
-    model.set_user_input(0, 2, 2, "-42€".to_string());
+        .set_user_input(0, 1, 2, "-123.348€".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 2, "-42€".to_string()).unwrap();
 
     // with a space
-    model.set_user_input(0, 1, 3, "101.348 €".to_string());
+    model
-    model.set_user_input(0, 2, 3, "26 €".to_string());
+        .set_user_input(0, 1, 3, "101.348 €".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 3, "26 €".to_string()).unwrap();
 
-    model.set_user_input(0, 1, 4, "-12.348 €".to_string());
+    model
-    model.set_user_input(0, 2, 4, "-45 €".to_string());
+        .set_user_input(0, 1, 4, "-12.348 €".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 4, "-45 €".to_string()).unwrap();
 
     model.evaluate();
 
@@ -449,9 +503,15 @@ fn test_sum_function_eur() {
     model._set("A1", "€100");
     model._set("A2", "€300");
 
-    model.set_user_input(0, 1, 2, "=SUM(A:A)".to_string());
+    model
-    model.set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string());
+        .set_user_input(0, 1, 2, "=SUM(A:A)".to_string())
-    model.set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string());
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -463,7 +523,9 @@ fn test_sum_function_eur() {
 #[test]
 fn input_dates() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "3/4/2025".to_string());
+    model
+        .set_user_input(0, 1, 1, "3/4/2025".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -474,7 +536,9 @@ fn input_dates() {
     );
 
     // further date assignments do not change the format
-    model.set_user_input(0, 1, 1, "08-08-2028".to_string());
+    model
+        .set_user_input(0, 1, 1, "08-08-2028".to_string())
+        .unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A1"), "8/8/2028");
 }

base/src/test/test_sheet_markup.rs

@@ -14,7 +14,7 @@ fn test_sheet_markup() {
     model._set("A4", "Total");
     model._set("B4", "=SUM(B2:B3)");
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.font.b = true;
     model.set_cell_style(0, 1, 1, &style).unwrap();
     model.set_cell_style(0, 1, 2, &style).unwrap();

base/src/test/test_sheets.rs

@@ -138,14 +138,14 @@ fn test_insert_sheet() {
 
     // Insert the sheet at the end and check the formula
     assert!(model.insert_sheet("Bacchus", 1, None).is_ok());
-    model.set_user_input(1, 3, 1, "42".to_string());
+    model.set_user_input(1, 3, 1, "42".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A1"), "42");
     assert_eq!(model._get_text("A2"), "#REF!");
 
     // Insert a sheet in between the other two
     assert!(model.insert_sheet("Dionysus", 1, None).is_ok());
-    model.set_user_input(1, 3, 1, "111".to_string());
+    model.set_user_input(1, 3, 1, "111".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A1"), "42");
     assert_eq!(model._get_text("A2"), "111");
@@ -176,7 +176,7 @@ fn test_rename_sheet() {
     let mut model = new_empty_model();
     model.new_sheet();
     model._set("A1", "=NewSheet!A3");
-    model.set_user_input(1, 3, 1, "25".to_string());
+    model.set_user_input(1, 3, 1, "25".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A1"), "#REF!");
     assert!(model.rename_sheet("Sheet2", "NewSheet").is_ok());
@@ -189,7 +189,7 @@ fn test_rename_sheet_by_index() {
     let mut model = new_empty_model();
     model.new_sheet();
     model._set("A1", "=NewSheet!A1");
-    model.set_user_input(1, 1, 1, "25".to_string());
+    model.set_user_input(1, 1, 1, "25".to_string()).unwrap();
     model.evaluate();
     assert_eq!(model._get_text("A1"), "#REF!");
     assert!(model.rename_sheet_by_index(1, "NewSheet").is_ok());

base/src/test/test_styles.rs

@@ -7,10 +7,10 @@ use crate::types::Style;
 fn test_model_set_cells_with_values_styles() {
     let mut model = new_empty_model();
     // Inputs
-    model.set_user_input(0, 1, 1, "21".to_string()); // A1
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
-    model.set_user_input(0, 2, 1, "42".to_string()); // A2
+    model.set_user_input(0, 2, 1, "42".to_string()).unwrap(); // A2
 
-    let style_base = model.get_style_for_cell(0, 1, 1);
+    let style_base = model.get_style_for_cell(0, 1, 1).unwrap();
     let mut style = style_base.clone();
     style.font.b = true;
     style.num_fmt = "#,##0.00".to_string();
@@ -19,7 +19,7 @@ fn test_model_set_cells_with_values_styles() {
     let mut style = style_base;
     style.num_fmt = "#,##0.00".to_string();
     assert!(model.set_cell_style(0, 2, 1, &style).is_ok());
-    let style: Style = model.get_style_for_cell(0, 2, 1);
+    let style: Style = model.get_style_for_cell(0, 2, 1).unwrap();
     assert_eq!(style.num_fmt, "#,##0.00".to_string());
 }
 
@@ -27,21 +27,21 @@ fn test_model_set_cells_with_values_styles() {
 fn test_named_styles() {
     let mut model = new_empty_model();
     model._set("A1", "42");
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
-    let bold_style_index = model.get_cell_style_index(0, 1, 1);
+    let bold_style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     let e = model
         .workbook
         .styles
         .add_named_cell_style("bold", bold_style_index);
     assert!(e.is_ok());
     model._set("A2", "420");
-    let a2_style_index = model.get_cell_style_index(0, 2, 1);
+    let a2_style_index = model.get_cell_style_index(0, 2, 1).unwrap();
     assert!(a2_style_index != bold_style_index);
     let e = model.set_cell_style_by_name(0, 2, 1, "bold");
     assert!(e.is_ok());
-    assert_eq!(model.get_cell_style_index(0, 2, 1), bold_style_index);
+    assert_eq!(model.get_cell_style_index(0, 2, 1), Ok(bold_style_index));
 }
 
 #[test]
@@ -49,7 +49,7 @@ fn test_create_named_style() {
     let mut model = new_empty_model();
     model._set("A1", "42");
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(!style.font.b);
 
     style.font.b = true;
@@ -59,6 +59,6 @@ fn test_create_named_style() {
     let e = model.set_cell_style_by_name(0, 1, 1, "bold");
     assert!(e.is_ok());
 
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
 }

base/src/test/test_worksheet.rs

@@ -100,7 +100,9 @@ fn test_worksheet_dimension_progressive() {
         }
     );
 
-    model.set_user_input(0, 30, 50, "Hello World".to_string());
+    model
+        .set_user_input(0, 30, 50, "Hello World".to_string())
+        .unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -111,7 +113,9 @@ fn test_worksheet_dimension_progressive() {
         }
     );
 
-    model.set_user_input(0, 10, 15, "Hello World".to_string());
+    model
+        .set_user_input(0, 10, 15, "Hello World".to_string())
+        .unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -122,7 +126,9 @@ fn test_worksheet_dimension_progressive() {
         }
     );
 
-    model.set_user_input(0, 5, 25, "Hello World".to_string());
+    model
+        .set_user_input(0, 5, 25, "Hello World".to_string())
+        .unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -133,7 +139,9 @@ fn test_worksheet_dimension_progressive() {
         }
     );
 
-    model.set_user_input(0, 10, 250, "Hello World".to_string());
+    model
+        .set_user_input(0, 10, 250, "Hello World".to_string())
+        .unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -162,12 +170,14 @@ fn test_worksheet_navigate_to_edge_in_direction() {
     for (row_index, row) in inline_spreadsheet.into_iter().enumerate() {
         for (column_index, value) in row.into_iter().enumerate() {
             if value != 0 {
-                model.update_cell_with_number(
+                model
-                    0,
+                    .update_cell_with_number(
-                    (row_index as i32) + 1,
+                        0,
-                    (column_index as i32) + 1,
+                        (row_index as i32) + 1,
-                    value.into(),
+                        (column_index as i32) + 1,
-                );
+                        value.into(),
+                    )
+                    .unwrap();
             }
         }
     }

base/src/test/user_model/mod.rs

@@ -1,14 +1,24 @@
 mod test_add_delete_sheets;
 mod test_autofill_columns;
 mod test_autofill_rows;
+mod test_border;
 mod test_clear_cells;
+mod test_defined_names;
 mod test_diff_queue;
 mod test_evaluation;
 mod test_general;
 mod test_grid_lines;
+mod test_keyboard_navigation;
+mod test_on_area_selection;
+mod test_on_expand_selected_range;
+mod test_on_paste_styles;
+mod test_paste_csv;
 mod test_rename_sheet;
 mod test_row_column;
+mod test_sheet_state;
 mod test_styles;
 mod test_to_from_bytes;
 mod test_undo_redo;
 mod test_view;
+mod test_window_size;
+mod util;

base/src/test/user_model/test_add_delete_sheets.rs

@@ -5,13 +5,13 @@ use crate::{constants::DEFAULT_COLUMN_WIDTH, UserModel};
 #[test]
 fn add_undo_redo() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.set_user_input(1, 1, 1, "=1 + 1").unwrap();
     model.set_user_input(1, 1, 2, "=A1*3").unwrap();
     model
         .set_column_width(1, 5, 5.0 * DEFAULT_COLUMN_WIDTH)
         .unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.set_user_input(2, 1, 1, "=Sheet2!B1").unwrap();
 
     model.undo().unwrap();
@@ -59,7 +59,7 @@ fn set_sheet_color() {
 #[test]
 fn new_sheet_propagates() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
 
     let send_queue = model.flush_send_queue();
 
@@ -72,7 +72,7 @@ fn new_sheet_propagates() {
 #[test]
 fn delete_sheet_propagates() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
     model.delete_sheet(0).unwrap();
 
     let send_queue = model.flush_send_queue();
@@ -82,3 +82,23 @@ fn delete_sheet_propagates() {
     let sheets_info = model2.get_worksheets_properties();
     assert_eq!(sheets_info.len(), 1);
 }
+
+#[test]
+fn delete_last_sheet() {
+    // Deleting the last sheet, selects the previous
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.new_sheet().unwrap();
+    model.new_sheet().unwrap();
+    model.set_selected_sheet(2).unwrap();
+    model.delete_sheet(2).unwrap();
+
+    assert_eq!(model.get_selected_sheet(), 1);
+}
+
+#[test]
+fn new_sheet_selects_it() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+    model.new_sheet().unwrap();
+    assert_eq!(model.get_selected_sheet(), 1);
+}

base/src/test/user_model/test_defined_names.rs

@@ -0,0 +1,398 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::UserModel;
+
+#[test]
+fn create_defined_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model
+        .new_defined_name("myName", None, "Sheet1!$A$1")
+        .unwrap();
+    model.set_user_input(0, 5, 7, "=myName").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+
+    assert_eq!(
+        model.get_defined_name_list(),
+        vec![("myName".to_string(), None, "Sheet1!$A$1".to_string())]
+    );
+
+    // delete it
+    model.delete_defined_name("myName", None).unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("#NAME?".to_string())
+    );
+
+    assert_eq!(model.get_defined_name_list().len(), 0);
+
+    model.undo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+}
+
+#[test]
+fn scopes() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+
+    // Global
+    model
+        .new_defined_name("myName", None, "Sheet1!$A$1")
+        .unwrap();
+    model.set_user_input(0, 5, 7, "=myName").unwrap();
+
+    // Local to Sheet2
+    model.new_sheet().unwrap();
+    model.set_user_input(1, 2, 1, "145").unwrap();
+    model
+        .new_defined_name("myName", Some(1), "Sheet2!$A$2")
+        .unwrap();
+    model.set_user_input(1, 8, 8, "=myName").unwrap();
+
+    // Sheet 3
+    model.new_sheet().unwrap();
+    model.set_user_input(2, 2, 2, "=myName").unwrap();
+
+    // Global
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(1, 8, 8),
+        Ok("145".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(2, 2, 2),
+        Ok("42".to_string())
+    );
+}
+
+#[test]
+fn delete_sheet() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
+        .unwrap();
+    model.new_sheet().unwrap();
+    model
+        .new_defined_name("myName", Some(1), "Sheet1!$A$1")
+        .unwrap();
+    model
+        .set_user_input(1, 2, 1, r#"=CONCATENATE(MyName, " my world!")"#)
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("#NAME?".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(1, 2, 1),
+        Ok("Hello my world!".to_string())
+    );
+
+    model.delete_sheet(0).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("#NAME?".to_string())
+    );
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok(r#"=CONCATENATE(MyName," my world!")"#.to_string())
+    );
+}
+
+#[test]
+fn change_scope() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
+        .unwrap();
+    model.new_sheet().unwrap();
+    model
+        .new_defined_name("myName", Some(1), "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("#NAME?".to_string())
+    );
+
+    model
+        .update_defined_name("myName", Some(1), "myName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("Hello world!".to_string())
+    );
+}
+
+#[test]
+fn rename_defined_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .set_user_input(0, 2, 1, r#"=CONCATENATE(MyName, " world!")"#)
+        .unwrap();
+    model.new_sheet().unwrap();
+    model
+        .new_defined_name("myName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("Hello world!".to_string())
+    );
+
+    model
+        .update_defined_name("myName", None, "newName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("Hello world!".to_string())
+    );
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok(r#"=CONCATENATE(newName," world!")"#.to_string())
+    );
+}
+
+#[test]
+fn rename_defined_name_operations() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "123").unwrap();
+
+    model
+        .new_defined_name("answer", None, "Sheet1!$A$1")
+        .unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "=IF(answer<2, answer*2, answer^2)")
+        .unwrap();
+
+    model
+        .set_user_input(0, 3, 1, "=badDunction(-answer)")
+        .unwrap();
+
+    model.new_sheet().unwrap();
+    model.set_user_input(1, 1, 1, "78").unwrap();
+    model
+        .new_defined_name("answer", Some(1), "Sheet1!$A$1")
+        .unwrap();
+
+    model.set_user_input(1, 3, 1, "=answer").unwrap();
+
+    model
+        .update_defined_name("answer", None, "respuesta", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok("=IF(respuesta<2,respuesta*2,respuesta^2)".to_string())
+    );
+
+    assert_eq!(
+        model.get_cell_content(0, 3, 1),
+        Ok("=badDunction(-respuesta)".to_string())
+    );
+
+    // A defined name with the same name but different scope
+    assert_eq!(model.get_cell_content(1, 3, 1), Ok("=answer".to_string()));
+}
+
+#[test]
+fn rename_defined_name_string_operations() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model.set_user_input(0, 1, 2, "World").unwrap();
+
+    model
+        .new_defined_name("hello", None, "Sheet1!$A$1")
+        .unwrap();
+
+    model
+        .new_defined_name("world", None, "Sheet1!$B$1")
+        .unwrap();
+
+    model.set_user_input(0, 2, 1, "=hello&world").unwrap();
+
+    model
+        .update_defined_name("hello", None, "HolaS", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_cell_content(0, 2, 1),
+        Ok("=HolaS&world".to_string())
+    );
+}
+
+#[test]
+fn invalid_names() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    // spaces
+    assert_eq!(
+        model.new_defined_name("A real", None, "Sheet1!$A$1"),
+        Err("Invalid defined name".to_string())
+    );
+
+    // Starts with number
+    assert_eq!(
+        model.new_defined_name("2real", None, "Sheet1!$A$1"),
+        Err("Invalid defined name".to_string())
+    );
+
+    // Updating also fails
+    assert_eq!(
+        model.update_defined_name("MyName", None, "My Name", None, "Sheet1!$A$1"),
+        Err("Invalid defined name".to_string())
+    );
+}
+
+#[test]
+fn already_existing() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+    model
+        .new_defined_name("Another", None, "Sheet1!$A$1")
+        .unwrap();
+
+    // Can't create a new name with the same name
+    assert_eq!(
+        model.new_defined_name("MyName", None, "Sheet1!$A$2"),
+        Err("Defined name already exists".to_string())
+    );
+
+    // Can't update one into an existing
+    assert_eq!(
+        model.update_defined_name("Another", None, "MyName", None, "Sheet1!$A$1"),
+        Err("Defined name already exists".to_string())
+    );
+}
+
+#[test]
+fn invalid_sheet() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.new_defined_name("Mything", Some(2), "Sheet1!$A$1"),
+        Err("Invalid sheet index".to_string())
+    );
+
+    assert_eq!(
+        model.update_defined_name("MyName", None, "MyName", Some(2), "Sheet1!$A$1"),
+        Err("Invalid sheet index".to_string())
+    );
+
+    assert_eq!(
+        model.update_defined_name("MyName", Some(9), "YourName", None, "Sheet1!$A$1"),
+        Err("Invalid sheet index".to_string())
+    );
+}
+
+#[test]
+fn invalid_formula() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model.new_defined_name("MyName", None, "A1").unwrap();
+
+    model.set_user_input(0, 1, 2, "=MyName").unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("#NAME?".to_string())
+    );
+}
+
+#[test]
+fn undo_redo() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "Hello").unwrap();
+    model.set_user_input(0, 2, 1, "Hola").unwrap();
+    model.set_user_input(0, 1, 2, r#"=MyName&"!""#).unwrap();
+
+    model
+        .new_defined_name("MyName", None, "Sheet1!$A$1")
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello!".to_string())
+    );
+    model.undo().unwrap();
+    assert_eq!(model.get_defined_name_list().len(), 0);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("#NAME?".to_string())
+    );
+    model.redo().unwrap();
+
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello!".to_string())
+    );
+
+    model
+        .update_defined_name("MyName", None, "MyName", None, "Sheet1!$A$2")
+        .unwrap();
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hola!".to_string())
+    );
+    model.undo().unwrap();
+
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello!".to_string())
+    );
+
+    model.redo().unwrap();
+
+    assert_eq!(model.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("Hola!".to_string())
+    );
+
+    let send_queue = model.flush_send_queue();
+
+    let mut model2 = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(model2.get_defined_name_list().len(), 1);
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 1, 2),
+        Ok("Hola!".to_string())
+    );
+}

base/src/test/user_model/test_diff_queue.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use crate::{
     constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT},
     test::util::new_empty_model,
@@ -138,7 +140,7 @@ fn queue_undo_redo_multiple() {
 #[test]
 fn new_sheet() {
     let mut model1 = UserModel::from_model(new_empty_model());
-    model1.new_sheet();
+    model1.new_sheet().unwrap();
     model1.set_user_input(0, 1, 1, "42").unwrap();
     model1.set_user_input(1, 1, 1, "=Sheet1!A1*2").unwrap();
 

base/src/test/user_model/test_general.rs

@@ -91,7 +91,6 @@ fn insert_remove_columns() {
     let mut model = UserModel::from_model(model);
     // column E
     let column_width = model.get_column_width(0, 5).unwrap();
-    println!("{column_width}");
 
     // Insert some data in row 5 (and change the style) in E1
     assert!(model.set_user_input(0, 1, 5, "100$").is_ok());
@@ -129,3 +128,12 @@ fn delete_remove_cell() {
     let (sheet, row, column) = (0, 1, 1);
     model.set_user_input(sheet, row, column, "100$").unwrap();
 }
+
+#[test]
+fn get_and_set_name() {
+    let mut model = UserModel::new_empty("MyWorkbook123", "en", "UTC").unwrap();
+    assert_eq!(model.get_name(), "MyWorkbook123");
+
+    model.set_name("Another name");
+    assert_eq!(model.get_name(), "Another name");
+}

base/src/test/user_model/test_grid_lines.rs

@@ -7,7 +7,7 @@ use crate::UserModel;
 fn basic_tests() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
-    model.new_sheet();
+    model.new_sheet().unwrap();
 
     // default sheet has show_grid_lines = true
     assert_eq!(model.get_show_grid_lines(0), Ok(true));

base/src/test/user_model/test_keyboard_navigation.rs

@@ -0,0 +1,136 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{
+        DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH,
+        LAST_COLUMN,
+    },
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn basic_navigation() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 2, 1, 2]);
+    assert_eq!(view.column, 2);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_left().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_left().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_down().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [2, 1, 2, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 2);
+
+    model.on_arrow_up().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_up().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+}
+
+#[test]
+fn scroll_right() {
+    let window_width = DEFAULT_WINDOW_WIDTH as f64;
+    let column_width = DEFAULT_COLUMN_WIDTH;
+    let column_count = f64::floor(window_width / column_width) as i32;
+
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_arrow_right().unwrap();
+
+    model.set_selected_cell(3, column_count).unwrap();
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.left_column, 2);
+
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.left_column, 3);
+}
+
+#[test]
+fn last_colum() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(3, LAST_COLUMN).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.column, LAST_COLUMN);
+
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.column, LAST_COLUMN);
+}
+
+#[test]
+fn page_down() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let window_height = DEFAULT_WINDOW_HEIGHT as f64;
+    let row_height = DEFAULT_ROW_HEIGHT;
+    let row_count = f64::floor(window_height / row_height) as i32;
+    model.on_page_down().unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.row, 1 + row_count);
+    let scroll_y = model.get_scroll_y().unwrap();
+    assert_eq!(scroll_y, (row_count as f64) * DEFAULT_ROW_HEIGHT);
+}
+
+// we just test that page up and page down are inverse operations
+#[test]
+fn page_up() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_page_down().unwrap();
+    let row1 = model.get_selected_view().row;
+
+    model.on_page_down().unwrap();
+    let row2 = model.get_selected_view().row;
+
+    model.on_page_down().unwrap();
+    let row3 = model.get_selected_view().row;
+
+    model.on_page_down().unwrap();
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, row3);
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, row2);
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, row1);
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, 1);
+}
+
+#[test]
+fn page_up_fails_on_row1() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_arrow_up().unwrap();
+    assert_eq!(model.get_selected_view().row, 1);
+}

base/src/test/user_model/test_on_area_selection.rs

@@ -0,0 +1,33 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn basic_test() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    model.on_area_selecting(2, 4).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 2, 4]);
+}
+
+// this checks that is we select in the boundary we automatically scroll
+#[test]
+fn scroll_right() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let window_width = DEFAULT_WINDOW_WIDTH as f64;
+    let column_width = DEFAULT_COLUMN_WIDTH;
+    let column_count = f64::floor(window_width / column_width) as i32;
+    model.set_selected_cell(3, column_count).unwrap();
+
+    model.on_area_selecting(3, column_count + 3).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [3, column_count, 3, column_count + 3]);
+    assert_eq!(view.left_column, 4);
+}

base/src/test/user_model/test_on_expand_selected_range.rs

@@ -0,0 +1,151 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH, LAST_COLUMN},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn arrow_right() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_expand_selected_range("ArrowRight").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 2]);
+}
+
+#[test]
+fn arrow_right_decreases() {
+    // if the selected cell is on the upper right corner, right-arrow will decrease the size of teh area
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let (start_row, start_column, end_row, end_column) = (5, 3, 10, 8);
+    model.set_selected_cell(start_row, end_column).unwrap();
+    model
+        .set_selected_range(start_row, start_column, end_row, end_column)
+        .unwrap();
+
+    model.on_expand_selected_range("ArrowRight").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(
+        view.range,
+        [start_row, start_column + 1, end_row, end_column]
+    );
+}
+
+#[test]
+fn arrow_right_last_column() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(1, LAST_COLUMN).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, LAST_COLUMN, 1, LAST_COLUMN]);
+}
+
+#[test]
+fn arrow_right_scroll_right() {
+    let window_width = DEFAULT_WINDOW_WIDTH as f64;
+    let column_width = DEFAULT_COLUMN_WIDTH;
+    let column_count = f64::floor(window_width / column_width) as i32;
+
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    // initially the column to the left is A
+    let view = model.get_selected_view();
+    assert_eq!(view.left_column, 1);
+
+    // We select all columns from 1 to the last visible
+    let (start_row, start_column, end_row, end_column) = (1, 1, 1, column_count);
+    model.set_selected_cell(start_row, start_column).unwrap();
+    model
+        .set_selected_range(start_row, start_column, end_row, end_column)
+        .unwrap();
+
+    // Now we select one more column
+    model.on_expand_selected_range("ArrowRight").unwrap();
+
+    // The view has updated and the first visible column is B
+    let view = model.get_selected_view();
+    assert_eq!(
+        view.range,
+        [start_row, start_column, end_row, end_column + 1]
+    );
+    assert_eq!(view.left_column, 2);
+
+    // now we click on cell B2 and we
+    model.set_selected_cell(2, 2).unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [2, 1, 2, 2]);
+    assert_eq!(view.left_column, 1);
+
+    // a second arrow left won't do anything
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [2, 1, 2, 2]);
+    assert_eq!(view.left_column, 1);
+}
+
+#[test]
+fn arrow_left() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(5, 3).unwrap();
+    model.set_selected_range(5, 3, 10, 8).unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [5, 3, 10, 7]);
+}
+
+#[test]
+fn arrow_left_left_border() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+}
+
+#[test]
+fn arrow_left_increases() {
+    // If the selected cell is on the top right corner
+    // arrow left increases the selected area by
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    let (start_row, start_column, end_row, end_column) = (4, 10, 4, 20);
+    model.set_selected_cell(start_row, end_column).unwrap();
+    model
+        .set_selected_range(start_row, start_column, end_row, end_column)
+        .unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(
+        view.range,
+        [start_row, start_column - 1, end_row, end_column]
+    );
+}
+
+#[test]
+fn arrow_left_scrolls_left() {
+    // If the selected cell is on the top right corner
+    // arrow left increases the selected area by
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    model.set_top_left_visible_cell(1, 50).unwrap();
+
+    model.set_selected_cell(1, 50).unwrap();
+    // arrow left x 2
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 48, 1, 50]);
+    assert_eq!(view.left_column, 48);
+    assert_eq!(view.column, 50);
+}

base/src/test/user_model/test_on_paste_styles.rs

@@ -0,0 +1,48 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+use crate::types::Fill;
+use crate::UserModel;
+
+#[test]
+fn simple_pasting() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let mut style = model.get_cell_style(0, 1, 1).unwrap();
+    style.fill = Fill {
+        pattern_type: "solid".to_string(),
+        fg_color: Some("#FF5577".to_string()),
+        bg_color: Some("#33FF44".to_string()),
+    };
+    let styles = vec![vec![style.clone()]];
+
+    model.set_selected_cell(5, 4).unwrap();
+    model.set_selected_range(5, 4, 10, 9).unwrap();
+    model.on_paste_styles(&styles).unwrap();
+
+    for row in 5..10 {
+        for column in 4..9 {
+            let cell_style = model.get_cell_style(0, row, column).unwrap();
+            assert_eq!(cell_style, style);
+        }
+    }
+
+    model.undo().unwrap();
+    let base_style = model.get_cell_style(0, 100, 100).unwrap();
+
+    for row in 5..10 {
+        for column in 4..9 {
+            let cell_style = model.get_cell_style(0, row, column).unwrap();
+            assert_eq!(cell_style, base_style);
+        }
+    }
+
+    model.redo().unwrap();
+
+    for row in 5..10 {
+        for column in 4..9 {
+            let cell_style = model.get_cell_style(0, row, column).unwrap();
+            assert_eq!(cell_style, style);
+        }
+    }
+}

base/src/test/user_model/test_paste_csv.rs

@@ -0,0 +1,207 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, UserModel};
+
+#[test]
+fn csv_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 7, 7, "=SUM(B4:D7)").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
+
+    // paste some numbers in B4:C7
+    let csv = "1\t2\t3\n4\t5\t6";
+    let area = Area {
+        sheet: 0,
+        row: 4,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(4, 2).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 7),
+        Ok("21".to_string())
+    );
+}
+
+#[test]
+fn csv_paste_formula() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+
+    let csv = "=YEAR(TODAY())";
+    let area = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(1, 1).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("2022".to_string())
+    );
+}
+
+#[test]
+fn tsv_crlf_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 7, 7, "=SUM(B4:D7)").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
+
+    // paste some numbers in B4:C7
+    let csv = "1\t2\t3\r\n4\t5\t6";
+    let area = Area {
+        sheet: 0,
+        row: 4,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(4, 2).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 7),
+        Ok("21".to_string())
+    );
+}
+
+#[test]
+fn cut_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1*3+1").unwrap();
+
+    // set A1 bold
+    let range = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.update_range_style(&range, "font.b", "true").unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
+        .unwrap();
+
+    // Select A1:B2 and copy
+    model.set_selected_range(1, 1, 2, 2).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4)
+    model
+        .paste_from_clipboard(0, (1, 1, 2, 2), &copy.data, true)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+
+    // range A1:B2 must be empty
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 2), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 2, 1), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 2, 2), Ok("".to_string()));
+}
+
+#[test]
+fn cut_paste_different_sheet() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+
+    model.set_selected_range(1, 1, 1, 1).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+    model.new_sheet().unwrap();
+    model.set_selected_sheet(1).unwrap();
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4) of Sheet2
+    model
+        .paste_from_clipboard(0, (1, 1, 1, 1), &copy.data, true)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(1, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("".to_string()));
+}
+
+#[test]
+fn copy_paste_internal() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1*3+1").unwrap();
+
+    // set A1 bold
+    let range = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.update_range_style(&range, "font.b", "true").unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "A season of faith\t \"perfection\"")
+        .unwrap();
+
+    // Select A1:B2 and copy
+    model.set_selected_range(1, 1, 2, 2).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+    assert_eq!(
+        copy.csv,
+        "42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
+    );
+    assert_eq!(copy.range, (1, 1, 2, 2));
+
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4)
+    model
+        .paste_from_clipboard(0, (1, 1, 2, 2), &copy.data, false)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("".to_string()));
+    // cell D4 must not be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(!style_d4.font.b);
+
+    model.redo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+}

base/src/test/user_model/test_rename_sheet.rs

@@ -9,6 +9,13 @@ fn basic_rename() {
     assert_eq!(model.get_worksheets_properties()[0].name, "NewSheet");
 }
 
+#[test]
+fn rename_with_same_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.rename_sheet(0, "Sheet1").unwrap();
+    assert_eq!(model.get_worksheets_properties()[0].name, "Sheet1");
+}
+
 #[test]
 fn undo_redo() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();

base/src/test/user_model/test_row_column.rs

@@ -154,3 +154,21 @@ fn simple_delete_row_no_style() {
 
     assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
 }
+
+#[test]
+fn row_heigh_increases_automatically() {
+    let mut model = UserModel::new_empty("Workbook1", "en", "UTC").unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(DEFAULT_ROW_HEIGHT));
+
+    // Entering a single line does not change the height
+    model
+        .set_user_input(0, 1, 1, "My home in Canada had horses")
+        .unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(DEFAULT_ROW_HEIGHT));
+
+    // entering a two liner does:
+    model
+        .set_user_input(0, 1, 1, "My home in Canada had horses\nAnd monkeys!")
+        .unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(2.0 * DEFAULT_ROW_HEIGHT));
+}

base/src/test/user_model/test_sheet_state.rs

@@ -0,0 +1,57 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+use crate::UserModel;
+
+#[test]
+fn basic_tests() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    // add three more sheets
+    model.new_sheet().unwrap();
+    model.new_sheet().unwrap();
+    model.new_sheet().unwrap();
+
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.len(), 4);
+    for sheet in &info {
+        assert_eq!(sheet.state, "visible".to_string());
+    }
+
+    model.set_selected_sheet(2).unwrap();
+    assert_eq!(info.get(2).unwrap().name, "Sheet3".to_string());
+
+    model.hide_sheet(2).unwrap();
+
+    let info = model.get_worksheets_properties();
+    assert_eq!(model.get_selected_sheet(), 3);
+    assert_eq!(info.get(2).unwrap().state, "hidden".to_string());
+
+    model.undo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(2).unwrap().state, "visible".to_string());
+    model.redo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(2).unwrap().state, "hidden".to_string());
+
+    model.set_selected_sheet(3).unwrap();
+    model.hide_sheet(3).unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+
+    model.unhide_sheet(2).unwrap();
+    model.unhide_sheet(3).unwrap();
+
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.len(), 4);
+    for sheet in &info {
+        assert_eq!(sheet.state, "visible".to_string());
+    }
+
+    model.undo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(3).unwrap().state, "hidden".to_string());
+    model.redo().unwrap();
+    let info = model.get_worksheets_properties();
+    assert_eq!(info.get(3).unwrap().state, "visible".to_string());
+}

base/src/test/user_model/test_styles.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     expressions::types::Area,
-    types::{Alignment, BorderItem, BorderStyle, HorizontalAlignment, VerticalAlignment},
+    types::{Alignment, HorizontalAlignment, VerticalAlignment},
     UserModel,
 };
 
@@ -145,6 +145,7 @@ fn basic_fill() {
     let style = model.get_cell_style(0, 1, 1).unwrap();
     assert_eq!(style.fill.bg_color, None);
     assert_eq!(style.fill.fg_color, None);
+    assert_eq!(&style.fill.pattern_type, "none");
 
     // bg_color
     model
@@ -156,6 +157,7 @@ fn basic_fill() {
     let style = model.get_cell_style(0, 1, 1).unwrap();
     assert_eq!(style.fill.bg_color, Some("#F2F2F2".to_owned()));
     assert_eq!(style.fill.fg_color, Some("#F3F4F5".to_owned()));
+    assert_eq!(&style.fill.pattern_type, "solid");
 
     let send_queue = model.flush_send_queue();
 
@@ -227,157 +229,6 @@ fn basic_format() {
     assert_eq!(style.num_fmt, "$#,##0.0000");
 }
 
-#[test]
-fn basic_borders() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    model
-        .update_range_style(&range, "border.left", "thin,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "thin,")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: None,
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.right", "dotted,#F1F1F2")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.right,
-        Some(BorderItem {
-            style: BorderStyle::Dotted,
-            color: Some("#F1F1F2".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.top", "double,#F1F1F3")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.top,
-        Some(BorderItem {
-            style: BorderStyle::Double,
-            color: Some("#F1F1F3".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.bottom", "medium,#F1F1F4")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.bottom,
-        Some(BorderItem {
-            style: BorderStyle::Medium,
-            color: Some("#F1F1F4".to_owned()),
-        })
-    );
-
-    while model.can_undo() {
-        model.undo().unwrap();
-    }
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(style.border.left, None);
-    assert_eq!(style.border.top, None);
-    assert_eq!(style.border.right, None);
-    assert_eq!(style.border.bottom, None);
-
-    while model.can_redo() {
-        model.redo().unwrap();
-    }
-
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: None,
-        })
-    );
-    assert_eq!(
-        style.border.right,
-        Some(BorderItem {
-            style: BorderStyle::Dotted,
-            color: Some("#F1F1F2".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.top,
-        Some(BorderItem {
-            style: BorderStyle::Double,
-            color: Some("#F1F1F3".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.bottom,
-        Some(BorderItem {
-            style: BorderStyle::Medium,
-            color: Some("#F1F1F4".to_owned()),
-        })
-    );
-
-    let send_queue = model.flush_send_queue();
-
-    let mut model2 = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model2.apply_external_diffs(&send_queue).unwrap();
-
-    let style = model2.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thin,
-            color: None,
-        })
-    );
-    assert_eq!(
-        style.border.right,
-        Some(BorderItem {
-            style: BorderStyle::Dotted,
-            color: Some("#F1F1F2".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.top,
-        Some(BorderItem {
-            style: BorderStyle::Double,
-            color: Some("#F1F1F3".to_owned()),
-        })
-    );
-    assert_eq!(
-        style.border.bottom,
-        Some(BorderItem {
-            style: BorderStyle::Medium,
-            color: Some("#F1F1F4".to_owned()),
-        })
-    );
-}
-
 #[test]
 fn basic_alignment() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
@@ -565,142 +416,6 @@ fn basic_wrap_text() {
     );
 }
 
-#[test]
-fn more_basic_borders() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    model
-        .update_range_style(&range, "border.left", "thick,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::Thick,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "slantDashDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::SlantDashDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "mediumDashDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "mediumDashDotDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashDotDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model
-        .update_range_style(&range, "border.left", "mediumDashed,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashed,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-}
-
-#[test]
-fn border_errors() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-
-    assert_eq!(
-        model.update_range_style(&range, "border.lef", "thick,#F1F1F1"),
-        Err("Invalid style path: 'border.lef'.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", "thic,#F1F1F1"),
-        Err("Invalid border style: 'thic'.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", "thick,#F1F1F"),
-        Err("Invalid color: '#F1F1F'.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", " "),
-        Err("Invalid border value: ' '.".to_string())
-    );
-
-    assert_eq!(
-        model.update_range_style(&range, "border.left", "thick,#F1F1F1,thin"),
-        Err("Invalid border value: 'thick,#F1F1F1,thin'.".to_string())
-    );
-}
-
-#[test]
-fn empty_removes_border() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let range = Area {
-        sheet: 0,
-        row: 1,
-        column: 1,
-        width: 1,
-        height: 1,
-    };
-    model
-        .update_range_style(&range, "border.left", "mediumDashDotDot,#F1F1F1")
-        .unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(
-        style.border.left,
-        Some(BorderItem {
-            style: BorderStyle::MediumDashDotDot,
-            color: Some("#F1F1F1".to_owned()),
-        })
-    );
-
-    model.update_range_style(&range, "border.left", "").unwrap();
-    let style = model.get_cell_style(0, 1, 1).unwrap();
-    assert_eq!(style.border.left, None);
-}
-
 #[test]
 fn false_removes_value() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();

base/src/test/user_model/test_view.rs

@@ -52,19 +52,12 @@ fn set_the_cell_sets_the_range() {
 fn set_the_range_does_not_set_the_cell() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
-    model.set_selected_range(5, 4, 10, 6).unwrap();
-    assert_eq!(model.get_selected_sheet(), 0);
-    assert_eq!(model.get_selected_cell(), (0, 1, 1));
     assert_eq!(
-        model.get_selected_view(),
+        model.set_selected_range(5, 4, 10, 6),
-        SelectedView {
+        Err(
-            sheet: 0,
+            "The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
-            row: 1,
+                .to_string()
-            column: 1,
+        )
-            range: [5, 4, 10, 6],
-            top_row: 1,
-            left_column: 1
-        }
     );
 }
 
@@ -72,13 +65,13 @@ fn set_the_range_does_not_set_the_cell() {
 fn add_new_sheet_and_back() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
-    model.new_sheet();
+    model.new_sheet().unwrap();
-    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_sheet(), 1);
     model.set_selected_cell(5, 4).unwrap();
-    model.set_selected_sheet(1).unwrap();
-    assert_eq!(model.get_selected_cell(), (1, 1, 1));
     model.set_selected_sheet(0).unwrap();
-    assert_eq!(model.get_selected_cell(), (0, 5, 4));
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    model.set_selected_sheet(1).unwrap();
+    assert_eq!(model.get_selected_cell(), (1, 5, 4));
 }
 
 #[test]

base/src/test/user_model/test_window_size.rs

@@ -0,0 +1,29 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn basic_test() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let window_height = model.get_window_height().unwrap();
+    assert_eq!(window_height, DEFAULT_WINDOW_HEIGHT);
+
+    let window_width = model.get_window_width().unwrap();
+    assert_eq!(window_width, DEFAULT_WINDOW_WIDTH);
+
+    // Set the window height to double the default and check that page_down behaves as expected
+    model.set_window_height((window_height * 2) as f64);
+    model.on_page_down().unwrap();
+
+    let row_height = DEFAULT_ROW_HEIGHT;
+    let row_count = f64::floor((window_height * 2) as f64 / row_height) as i32;
+    let view = model.get_selected_view();
+    assert_eq!(view.row, 1 + row_count);
+    let scroll_y = model.get_scroll_y().unwrap();
+    assert_eq!(scroll_y, (row_count as f64) * DEFAULT_ROW_HEIGHT);
+}

base/src/test/user_model/util.rs

@@ -0,0 +1,75 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, types::Border, BorderArea, UserModel};
+
+impl UserModel {
+    pub fn _set_cell_border(&mut self, cell: &str, color: &str) {
+        let cell_reference = self.model._parse_reference(cell);
+        let column = cell_reference.column;
+        let row = cell_reference.row;
+        let border_area: BorderArea = serde_json::from_str(&format!(
+            r##"{{
+                "item": {{
+                    "style": "thin",
+                    "color": "{}"
+                }},
+                "type": "All"
+            }}"##,
+            color
+        ))
+        .unwrap();
+        let range = &Area {
+            sheet: 0,
+            row,
+            column,
+            width: 1,
+            height: 1,
+        };
+        self.set_area_with_border(range, &border_area).unwrap();
+    }
+
+    pub fn _set_area_border(&mut self, range: &str, color: &str, kind: &str) {
+        let s: Vec<&str> = range.split(':').collect();
+        let left = self.model._parse_reference(s[0]);
+        let right = self.model._parse_reference(s[1]);
+        let column = left.column;
+        let row = left.row;
+        let width = right.column - column + 1;
+        let height = right.row - row + 1;
+        let border_area: BorderArea = serde_json::from_str(&format!(
+            r##"{{
+                "item": {{
+                    "style": "thin",
+                    "color": "{}"
+                }},
+                "type": "{}"
+            }}"##,
+            color, kind
+        ))
+        .unwrap();
+        let range = &Area {
+            sheet: 0,
+            row,
+            column,
+            width,
+            height,
+        };
+        self.set_area_with_border(range, &border_area).unwrap();
+    }
+
+    pub fn _get_cell_border(&self, cell: &str) -> Border {
+        let cell_reference = self.model._parse_reference(cell);
+        let column = cell_reference.column;
+        let row = cell_reference.row;
+        let style = self.get_cell_style(0, row, column).unwrap();
+        style.border
+    }
+
+    pub fn _get_cell_actual_border(&self, cell: &str) -> Border {
+        let cell_reference = self.model._parse_reference(cell);
+        let column = cell_reference.column;
+        let row = cell_reference.row;
+        let style = self.model.get_style_for_cell(0, row, column).unwrap();
+        style.border
+    }
+}

base/src/test/util.rs

@@ -9,7 +9,7 @@ pub fn new_empty_model() -> Model {
 }
 
 impl Model {
-    fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
+    pub fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
         if cell.contains('!') {
             self.parse_reference(cell).unwrap()
         } else {
@@ -20,7 +20,8 @@ impl Model {
         let cell_reference = self._parse_reference(cell);
         let column = cell_reference.column;
         let row = cell_reference.row;
-        self.set_user_input(cell_reference.sheet, row, column, value.to_string());
+        self.set_user_input(cell_reference.sheet, row, column, value.to_string())
+            .unwrap();
     }
     pub fn _has_formula(&self, cell: &str) -> bool {
         self._get_formula_opt(cell).is_some()

base/src/types.rs

@@ -33,6 +33,10 @@ pub struct WorkbookSettings {
 pub struct WorkbookView {
     /// The index of the currently selected sheet.
     pub sheet: u32,
+    /// The current width of the window
+    pub window_width: i64,
+    /// The current height of the window
+    pub window_height: i64,
 }
 
 /// An internal representation of an IronCalc Workbook
@@ -574,7 +578,7 @@ impl Default for CellStyles {
     }
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, PartialOrd, Clone)]
 #[serde(rename_all = "lowercase")]
 pub enum BorderStyle {
     Thin,

base/src/units.rs

@@ -7,17 +7,20 @@ use crate::{
 
 pub enum Units {
     Number {
+        #[allow(dead_code)]
         group_separator: bool,
         precision: i32,
         num_fmt: String,
     },
     Currency {
+        #[allow(dead_code)]
         group_separator: bool,
         precision: i32,
         num_fmt: String,
         currency: String,
     },
     Percentage {
+        #[allow(dead_code)]
         group_separator: bool,
         precision: i32,
         num_fmt: String,
@@ -86,12 +89,15 @@ fn get_units_from_format_string(num_fmt: &str) -> Option<Units> {
 
 impl Model {
     fn compute_cell_units(&self, cell_reference: &CellReferenceIndex) -> Option<Units> {
-        let style = &self.get_style_for_cell(
+        let cell_style_res = &self.get_style_for_cell(
             cell_reference.sheet,
             cell_reference.row,
             cell_reference.column,
         );
-        get_units_from_format_string(&style.num_fmt)
+        match cell_style_res {
+            Ok(style) => get_units_from_format_string(&style.num_fmt),
+            Err(_) => None,
+        }
     }
 
     pub(crate) fn compute_node_units(
@@ -287,7 +293,9 @@ impl Model {
             Node::EmptyArgKind => None,
             Node::InvalidFunctionKind { .. } => None,
             Node::ArrayKind(_) => None,
-            Node::VariableKind(_) => None,
+            Node::DefinedNameKind(_) => None,
+            Node::TableNameKind(_) => None,
+            Node::WrongVariableKind(_) => None,
             Node::CompareKind { .. } => None,
             Node::OpPowerKind { .. } => None,
         }
@@ -303,6 +311,7 @@ impl Model {
             Function::Sum => self.units_fn_sum_like(args, cell),
             Function::Average => self.units_fn_sum_like(args, cell),
             Function::Pmt => self.units_fn_currency(args, cell),
+            Function::Fv => self.units_fn_currency(args, cell),
             Function::Nper => self.units_fn_currency(args, cell),
             Function::Npv => self.units_fn_currency(args, cell),
             Function::Irr => self.units_fn_percentage(args, cell),

base/src/user_model/border_utils.rs

@@ -0,0 +1,137 @@
+use crate::types::BorderItem;
+
+fn parse_color(s: &str) -> Option<(u8, u8, u8)> {
+    let s = s.trim_start_matches('#');
+    match s.len() {
+        6 => {
+            let r = u8::from_str_radix(&s[0..2], 16).ok()?;
+            let g = u8::from_str_radix(&s[2..4], 16).ok()?;
+            let b = u8::from_str_radix(&s[4..6], 16).ok()?;
+            Some((r, g, b))
+        }
+        3 => {
+            let r = u8::from_str_radix(&s[0..1], 16).ok()?;
+            let g = u8::from_str_radix(&s[1..2], 16).ok()?;
+            let b = u8::from_str_radix(&s[2..3], 16).ok()?;
+            // Expand single hex digits to full bytes
+            Some((r * 17, g * 17, b * 17))
+        }
+        _ => None,
+    }
+}
+
+fn compute_luminance(r: u8, g: u8, b: u8) -> f64 {
+    // Normalize RGB values to [0, 1]
+    let r = r as f64 / 255.0;
+    let g = g as f64 / 255.0;
+    let b = b as f64 / 255.0;
+    // Calculate luminance using the Rec. 601 formula
+    0.299 * r + 0.587 * g + 0.114 * b
+}
+
+fn is_max_color(a: &str, b: &str) -> bool {
+    let (ar, ag, ab) = match parse_color(a) {
+        Some(rgb) => rgb,
+        None => return false, // Invalid color format for 'a'
+    };
+
+    let (br, bg, bb) = match parse_color(b) {
+        Some(rgb) => rgb,
+        None => return false, // Invalid color format for 'b'
+    };
+
+    let luminance_a = compute_luminance(ar, ag, ab);
+    let luminance_b = compute_luminance(br, bg, bb);
+
+    // 'b' is heavier if its luminance is less than 'a's luminance
+    luminance_b < luminance_a
+}
+
+/// Is border b "heavier" than a?
+pub(crate) fn is_max_border(a: Option<&BorderItem>, b: Option<&BorderItem>) -> bool {
+    match (a, b) {
+        (_, None) => false,
+        (None, Some(_)) => true,
+        (Some(item_a), Some(item_b)) => {
+            if item_a.style < item_b.style {
+                return true;
+            } else if item_a.style > item_b.style {
+                return false;
+            }
+            match (&item_a.color, &item_b.color) {
+                (_, None) => false,
+                (None, Some(_)) => true,
+                (Some(color_a), Some(color_b)) => is_max_color(color_a, color_b),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::BorderStyle;
+
+    #[test]
+    fn compare_borders() {
+        let b = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FFF".to_string()),
+        };
+        // Some border *always* beats no border
+        assert!(is_max_border(None, Some(&b)));
+
+        // No border is beaten by some border
+        assert!(!is_max_border(Some(&b), None));
+    }
+
+    #[test]
+    fn basic_colors() {
+        // Black vs White
+        assert!(is_max_color("#FFFFFF", "#000000"));
+        assert!(!is_max_color("#000000", "#FFFFFF"));
+
+        // Red vs Dark Red
+        assert!(is_max_color("#FF0000", "#800000"));
+        assert!(!is_max_color("#800000", "#FF0000"));
+
+        // Green vs Dark Green
+        assert!(is_max_color("#00FF00", "#008000"));
+        assert!(!is_max_color("#008000", "#00FF00"));
+
+        // Blue vs Dark Blue
+        assert!(is_max_color("#0000FF", "#000080"));
+        assert!(!is_max_color("#000080", "#0000FF"));
+    }
+
+    #[test]
+    fn same_color() {
+        // Comparing the same color should return false
+        assert!(!is_max_color("#123456", "#123456"));
+    }
+
+    #[test]
+    fn edge_cases() {
+        // Colors with minimal luminance difference
+        assert!(!is_max_color("#000000", "#010101"));
+        assert!(!is_max_color("#FEFEFE", "#FFFFFF"));
+        assert!(!is_max_color("#7F7F7F", "#808080"));
+    }
+
+    #[test]
+    fn luminance_ordering() {
+        // Colors with known luminance differences
+        assert!(is_max_color("#CCCCCC", "#333333")); // Light gray vs Day
+        assert!(is_max_color("#FFFF00", "#808000")); // Yellow ve
+        assert!(is_max_color("#FF00FF", "#800080")); // Magenta vle
+    }
+
+    #[test]
+    fn borderline_cases() {
+        // Testing colors with equal luminance
+        assert!(!is_max_color("#777777", "#777777"));
+
+        // Testing black against near-black
+        assert!(!is_max_color("#000000", "#010000"));
+    }
+}

base/src/user_model/history.rs

@@ -0,0 +1,188 @@
+use std::collections::HashMap;
+
+use bitcode::{Decode, Encode};
+
+use crate::types::{Cell, Col, Row, SheetState, Style};
+
+#[derive(Clone, Encode, Decode)]
+pub(crate) struct RowData {
+    pub(crate) row: Option<Row>,
+    pub(crate) data: HashMap<i32, Cell>,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub(crate) struct ColumnData {
+    pub(crate) column: Option<Col>,
+    pub(crate) data: HashMap<i32, Cell>,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub(crate) enum Diff {
+    // Cell diffs
+    SetCellValue {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        new_value: String,
+        old_value: Box<Option<Cell>>,
+    },
+    CellClearContents {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        old_value: Box<Option<Cell>>,
+    },
+    CellClearAll {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        old_value: Box<Option<Cell>>,
+        old_style: Box<Style>,
+    },
+    SetCellStyle {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        old_value: Box<Style>,
+        new_value: Box<Style>,
+    },
+    // Column and Row diffs
+    SetColumnWidth {
+        sheet: u32,
+        column: i32,
+        new_value: f64,
+        old_value: f64,
+    },
+    SetRowHeight {
+        sheet: u32,
+        row: i32,
+        new_value: f64,
+        old_value: f64,
+    },
+    InsertRow {
+        sheet: u32,
+        row: i32,
+    },
+    DeleteRow {
+        sheet: u32,
+        row: i32,
+        old_data: Box<RowData>,
+    },
+    InsertColumn {
+        sheet: u32,
+        column: i32,
+    },
+    DeleteColumn {
+        sheet: u32,
+        column: i32,
+        old_data: Box<ColumnData>,
+    },
+    SetFrozenRowsCount {
+        sheet: u32,
+        new_value: i32,
+        old_value: i32,
+    },
+    SetFrozenColumnsCount {
+        sheet: u32,
+        new_value: i32,
+        old_value: i32,
+    },
+    DeleteSheet {
+        sheet: u32,
+    },
+    NewSheet {
+        index: u32,
+        name: String,
+    },
+    RenameSheet {
+        index: u32,
+        old_value: String,
+        new_value: String,
+    },
+    SetSheetColor {
+        index: u32,
+        old_value: String,
+        new_value: String,
+    },
+    SetSheetState {
+        index: u32,
+        old_value: SheetState,
+        new_value: SheetState,
+    },
+    SetShowGridLines {
+        sheet: u32,
+        old_value: bool,
+        new_value: bool,
+    },
+    CreateDefinedName {
+        name: String,
+        scope: Option<u32>,
+        value: String,
+    },
+    DeleteDefinedName {
+        name: String,
+        scope: Option<u32>,
+        old_value: String,
+    },
+    UpdateDefinedName {
+        name: String,
+        scope: Option<u32>,
+        old_formula: String,
+        new_name: String,
+        new_scope: Option<u32>,
+        new_formula: String,
+    },
+    // FIXME: we are missing SetViewDiffs
+}
+
+pub(crate) type DiffList = Vec<Diff>;
+
+#[derive(Default)]
+pub(crate) struct History {
+    pub(crate) undo_stack: Vec<DiffList>,
+    pub(crate) redo_stack: Vec<DiffList>,
+}
+
+impl History {
+    pub fn push(&mut self, diff_list: DiffList) {
+        self.undo_stack.push(diff_list);
+        self.redo_stack = vec![];
+    }
+
+    pub fn undo(&mut self) -> Option<Vec<Diff>> {
+        match self.undo_stack.pop() {
+            Some(diff_list) => {
+                self.redo_stack.push(diff_list.clone());
+                Some(diff_list)
+            }
+            None => None,
+        }
+    }
+
+    pub fn redo(&mut self) -> Option<Vec<Diff>> {
+        match self.redo_stack.pop() {
+            Some(diff_list) => {
+                self.undo_stack.push(diff_list.clone());
+                Some(diff_list)
+            }
+            None => None,
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.redo_stack = vec![];
+        self.undo_stack = vec![];
+    }
+}
+
+#[derive(Clone, Encode, Decode)]
+pub enum DiffType {
+    Undo,
+    Redo,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub struct QueueDiffs {
+    pub r#type: DiffType,
+    pub list: DiffList,
+}