BOB

Fixes #193

.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, push]
+on:
+  workflow_dispatch:
 
 jobs:
   coverage:
@@ -14,7 +15,7 @@ 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
         with:

.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.

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 {
@@ -202,7 +196,9 @@ impl 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(""),
         );
         Parser {
@@ -518,20 +514,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 +522,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,
@@ -675,14 +673,23 @@ impl Parser {
                         }
                     };
                     // 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 {
+                                formula: self.lexer.get_formula(),
+                                position: 0,
+                                message,
+                            };
+                        }
+                    };
                     let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
                         Some(i) => i,
                         None => {
@@ -701,6 +708,7 @@ impl Parser {
                     };
 
                     // context must be with tables.reference
+                    #[allow(clippy::expect_used)]
                     let (column_start, mut row_start, column_end, mut row_end) =
                         parse_range(&table.reference).expect("Failed parsing range");
 

base/src/expressions/parser/stringify.rs

@@ -456,11 +456,65 @@ 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(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | VariableKind(_)
+                | 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 { .. }
+                | VariableKind(_)
+                | 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)
         }

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,

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

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

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

@@ -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() {

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,

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

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

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

@@ -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,

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,
+                            error @ CalcResult::Error { .. } => return Err(error),
-                        }) {
+                            CalcResult::EmptyCell => {
-                            CalcResult::Number(value) => {
+                                if let Some(value) = handle_empty_cell()? {
                                     values.push(value);
                                 }
-                            error @ CalcResult::Error { .. } => return Err(error),
+                            }
                             _ => {
-                                // 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,
-                        *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(
+                Err(CalcResult::new_error(
-                                    error,
+                    error.clone(),
                     *cell,
                     "Expected number".to_string(),
-                                ));
+                ))
-                            }
+            },
-                        }
+        )
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
-                    error,
-                    *cell,
-                    "Expected number".to_string(),
-                ));
-            }
-        };
-        Ok(values)
     }
 
     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/logical.rs

@@ -136,6 +136,9 @@ impl Model {
     }
 
     pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
         let mut result = false;
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {

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

@@ -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

@@ -57,4 +57,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,15 @@ 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::{
         parser::{
+            move_formula::{move_formula, MoveContext},
             stringify::{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_row},
     },
     formatter::{
         format::{format_number, parse_formatted_number},
@@ -45,6 +41,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()
@@ -421,6 +418,7 @@ impl Model {
                 CalcResult::new_error(Error::NIMPL, cell, "Arrays not implemented".to_string())
             }
             VariableKind(defined_name) => {
+                println!("{:?}", defined_name);
                 let parsed_defined_name = self
                     .parsed_defined_names
                     .get(&(Some(cell.sheet), defined_name.to_lowercase())) // try getting local defined name
@@ -429,6 +427,7 @@ impl Model {
                             .get(&(None, defined_name.to_lowercase()))
                     }); // fallback to global
 
+                println!("Parsed: {:?}", defined_name);
                 if let Some(parsed_defined_name) = parsed_defined_name {
                     match parsed_defined_name {
                         ParsedDefinedName::CellReference(reference) => {
@@ -533,6 +532,7 @@ impl Model {
         }
     }
 
+    #[allow(clippy::expect_used)]
     fn cell_reference_to_string(
         &self,
         cell_reference: &CellReferenceIndex,
@@ -548,6 +548,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 +684,13 @@ impl Model {
         Err(format!("Invalid color: {}", color))
     }
 
+    /// 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)?;
+        worksheet.show_grid_lines = show_grid_lines;
+        Ok(())
+    }
+
     fn get_cell_value(&self, cell: &Cell, cell_reference: CellReferenceIndex) -> CalcResult {
         use Cell::*;
         match cell {
@@ -872,6 +880,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() {
@@ -1197,10 +1206,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(())
     /// # }
@@ -1211,23 +1220,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
@@ -1240,10 +1256,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(())
     /// # }
@@ -1254,17 +1270,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
@@ -1277,10 +1298,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(())
     /// # }
@@ -1291,17 +1312,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
@@ -1315,11 +1341,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(())
@@ -1338,12 +1364,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('=')
@@ -1383,31 +1409,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];
@@ -1415,15 +1446,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;
@@ -1436,35 +1463,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(
@@ -1505,24 +1536,66 @@ 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)
     }
 
     /// Gets the Excel Value (Bool, Number, String) of a cell
@@ -1589,7 +1662,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
@@ -1692,7 +1765,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(())
     }
 
@@ -1727,43 +1800,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
@@ -1803,7 +1873,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}**")
                 }
@@ -1918,10 +1988,100 @@ 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> {
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        // if the defined name already exist return error
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == scope {
+                return Err("Defined name already exists".to_string());
+            }
+        }
+        self.workbook.defined_names.push(DefinedName {
+            name: name.to_string(),
+            formula: formula.to_string(),
+            sheet_id: scope,
+        });
+        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 mut index = None;
+        for (i, df) in defined_names.iter().enumerate() {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == scope {
+                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())
+        }
+    }
+
+    /// returns the formula for a defined name
+    pub 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;
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == scope {
+                return Ok(df.formula.clone());
+            }
+        }
+        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> {
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let mut index = None;
+        for (i, df) in defined_names.iter().enumerate() {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == scope {
+                index = Some(i);
+            }
+        }
+        if let Some(i) = index {
+            if let Some(df) = self.workbook.defined_names.get_mut(i) {
+                df.name = new_name.to_string();
+                df.sheet_id = new_scope;
+                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::{
@@ -65,6 +66,7 @@ impl Model {
             color: Default::default(),
             frozen_columns: 0,
             frozen_rows: 0,
+            show_grid_lines: true,
             views,
         }
     }
@@ -352,7 +354,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 {
@@ -383,6 +392,7 @@ impl Model {
         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,6 +15,7 @@ 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;
@@ -24,6 +25,7 @@ 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;
@@ -44,14 +46,19 @@ pub(crate) mod util;
 
 mod engineering;
 mod test_fn_offset;
+mod test_fn_or;
 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.rs

@@ -0,0 +1,36 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_or() {
+    let mut model = new_empty_model();
+    model._set("A1", "=OR(1, 0)");
+    model._set("A2", "=OR(0, 0)");
+    model._set("A3", "=OR(true, false)");
+    model._set("A4", "=OR(false, false)");
+
+    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");
+}
+
+#[test]
+fn fn_or_no_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=OR()");
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn fn_or_missing_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=OR(,)");
+    model._set("A2", "=OR(,1)");
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"FALSE");
+    assert_eq!(model._get_text("A2"), *"TRUE");
+}

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
+                    .update_cell_with_number(
                         0,
                         (row_index as i32) + 1,
                         (column_index as i32) + 1,
                         value.into(),
-                );
+                    )
+                    .unwrap();
             }
         }
     }

base/src/test/user_model/mod.rs

@@ -1,11 +1,23 @@
 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_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_autofill_columns.rs

@@ -0,0 +1,404 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::expressions::types::Area;
+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);
+    // This is cell A3
+    model.set_user_input(0, 3, 1, "alpha").unwrap();
+    // We autofill from A3 to C3
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 3,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+    // B3
+    assert_eq!(
+        model.get_formatted_cell_value(0, 3, 2),
+        Ok("alpha".to_string())
+    );
+    // C3
+    assert_eq!(
+        model.get_formatted_cell_value(0, 3, 3),
+        Ok("alpha".to_string())
+    );
+}
+
+#[test]
+fn one_cell_right() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            2,
+        )
+        .unwrap();
+    // B1
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("23".to_string())
+    );
+}
+
+#[test]
+fn alpha_beta_gamma() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:B3
+    model.set_user_input(0, 1, 1, "Alpher").unwrap(); // A1
+    model.set_user_input(0, 1, 2, "Bethe").unwrap(); // B1
+    model.set_user_input(0, 1, 3, "Gamow").unwrap(); // C1
+    model.set_user_input(0, 2, 1, "=A1").unwrap(); // A2
+    model.set_user_input(0, 2, 2, "=B1").unwrap(); // B2
+    model.set_user_input(0, 2, 3, "=C1").unwrap(); // C2
+
+    // We autofill from A1:C2 to I2
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 3,
+                height: 2,
+            },
+            9,
+        )
+        .unwrap();
+
+    // D1
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 4),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 5),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 6),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 7),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 8),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 9),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 4),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 5),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 6),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 7),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 8),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 9),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(model.get_cell_content(0, 2, 4), Ok("=D1".to_string()));
+}
+
+#[test]
+fn styles() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:C1
+    model.set_user_input(0, 1, 1, "Alpher").unwrap();
+    model.set_user_input(0, 2, 1, "Bethe").unwrap();
+    model.set_user_input(0, 3, 1, "Gamow").unwrap();
+
+    let b1 = Area {
+        sheet: 0,
+        row: 1,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+
+    let c1 = Area {
+        sheet: 0,
+        row: 1,
+        column: 3,
+        width: 1,
+        height: 1,
+    };
+
+    model.update_range_style(&b1, "font.i", "true").unwrap();
+    model
+        .update_range_style(&c1, "fill.bg_color", "#334455")
+        .unwrap();
+
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 3,
+                height: 1,
+            },
+            9,
+        )
+        .unwrap();
+
+    // Check that cell E1 has B1 style
+    let style = model.get_cell_style(0, 1, 5).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 1, 6).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 1, 4), Ok("".to_string()));
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 1, 5).unwrap();
+    assert!(!style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 1, 6).unwrap();
+    assert_eq!(style.fill.bg_color, None);
+
+    model.redo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 4),
+        Ok("Alpher".to_string())
+    );
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 1, 5).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 1, 6).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+}
+
+#[test]
+fn left() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A12
+    model.set_user_input(0, 1, 10, "Alpher").unwrap();
+    model.set_user_input(0, 1, 11, "Bethe").unwrap();
+    model.set_user_input(0, 1, 12, "Gamow").unwrap();
+
+    // We fill upwards to row 5
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 10,
+                width: 3,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 9),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 8),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 7),
+        Ok("Alpher".to_string())
+    );
+}
+
+#[test]
+fn left_4() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A13
+    model.set_user_input(0, 1, 10, "Margaret Burbidge").unwrap();
+    model.set_user_input(0, 1, 11, "Geoffrey Burbidge").unwrap();
+    model.set_user_input(0, 1, 12, "Willy Fowler").unwrap();
+    model.set_user_input(0, 1, 13, "Fred Hoyle").unwrap();
+
+    // We fill left to row 5
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 10,
+                width: 4,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 9),
+        Ok("Fred Hoyle".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 8),
+        Ok("Willy Fowler".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 5),
+        Ok("Fred Hoyle".to_string())
+    );
+}
+
+#[test]
+fn errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    model.set_user_input(0, 1, 4, "Margaret Burbidge").unwrap();
+
+    // Invalid sheet
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 3,
+                row: 1,
+                column: 4,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid worksheet index: '3'".to_string())
+    );
+
+    // invalid column
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: -1,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid column: '-1'".to_string())
+    );
+
+    // invalid column
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: LAST_COLUMN - 1,
+                width: 10,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid column: '16392'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: LAST_ROW + 1,
+                column: 1,
+                width: 10,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid row: '1048577'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: LAST_ROW - 2,
+                column: 1,
+                width: 1,
+                height: 10,
+            },
+            10,
+        ),
+        Err("Invalid row: '1048583'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 5,
+                width: 10,
+                height: 1,
+            },
+            -10,
+        ),
+        Err("Invalid row: '-10'".to_string())
+    );
+}
+
+#[test]
+fn invalid_parameters() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 2,
+                height: 1,
+            },
+            2,
+        ),
+        Err("Invalid parameters for autofill".to_string())
+    );
+}

base/src/test/user_model/test_autofill_rows.rs

@@ -0,0 +1,399 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::expressions::types::Area;
+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);
+    // This is cell A3
+    model.set_user_input(0, 3, 1, "alpha").unwrap();
+    // We autofill from A3 to A5
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 3,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 1),
+        Ok("alpha".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("alpha".to_string())
+    );
+}
+
+#[test]
+fn one_cell_down() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            2,
+        )
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("23".to_string())
+    );
+}
+
+#[test]
+fn alpha_beta_gamma() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:B3
+    model.set_user_input(0, 1, 1, "Alpher").unwrap();
+    model.set_user_input(0, 2, 1, "Bethe").unwrap();
+    model.set_user_input(0, 3, 1, "Gamow").unwrap();
+    model.set_user_input(0, 1, 2, "=A1").unwrap();
+    model.set_user_input(0, 2, 2, "=A2").unwrap();
+    model.set_user_input(0, 3, 2, "=A3").unwrap();
+    // We autofill from A1:B3 to A9
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 2,
+                height: 3,
+            },
+            9,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 1),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 1),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 1),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 1),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 1),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 2),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 2),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 2),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 2),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 2),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 2),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(model.get_cell_content(0, 4, 2), Ok("=A4".to_string()));
+}
+
+#[test]
+fn styles() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:B3
+    model.set_user_input(0, 1, 1, "Alpher").unwrap();
+    model.set_user_input(0, 2, 1, "Bethe").unwrap();
+    model.set_user_input(0, 3, 1, "Gamow").unwrap();
+
+    let a2 = Area {
+        sheet: 0,
+        row: 2,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+
+    let a3 = Area {
+        sheet: 0,
+        row: 3,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+
+    model.update_range_style(&a2, "font.i", "true").unwrap();
+    model
+        .update_range_style(&a3, "fill.bg_color", "#334455")
+        .unwrap();
+
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 3,
+            },
+            9,
+        )
+        .unwrap();
+
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 5, 1).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 6, 1).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 1), Ok("".to_string()));
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 5, 1).unwrap();
+    assert!(!style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 6, 1).unwrap();
+    assert_eq!(style.fill.bg_color, None);
+
+    model.redo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 1),
+        Ok("Alpher".to_string())
+    );
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 5, 1).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 6, 1).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+}
+
+#[test]
+fn upwards() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A12
+    model.set_user_input(0, 10, 1, "Alpher").unwrap();
+    model.set_user_input(0, 11, 1, "Bethe").unwrap();
+    model.set_user_input(0, 12, 1, "Gamow").unwrap();
+
+    // We fill upwards to row 5
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 10,
+                column: 1,
+                width: 1,
+                height: 3,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 1),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 1),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 1),
+        Ok("Alpher".to_string())
+    );
+}
+
+#[test]
+fn upwards_4() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A13
+    model.set_user_input(0, 10, 1, "Margaret Burbidge").unwrap();
+    model.set_user_input(0, 11, 1, "Geoffrey Burbidge").unwrap();
+    model.set_user_input(0, 12, 1, "Willy Fowler").unwrap();
+    model.set_user_input(0, 13, 1, "Fred Hoyle").unwrap();
+
+    // We fill upwards to row 5
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 10,
+                column: 1,
+                width: 1,
+                height: 4,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 1),
+        Ok("Fred Hoyle".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 1),
+        Ok("Willy Fowler".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("Fred Hoyle".to_string())
+    );
+}
+
+#[test]
+fn errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A13
+    model.set_user_input(0, 4, 1, "Margaret Burbidge").unwrap();
+
+    // Invalid sheet
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 3,
+                row: 4,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid worksheet index: '3'".to_string())
+    );
+
+    // invalid row
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: -1,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid row: '-1'".to_string())
+    );
+
+    // invalid row
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: LAST_ROW - 1,
+                column: 1,
+                width: 1,
+                height: 10,
+            },
+            10,
+        ),
+        Err("Invalid row: '1048584'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: LAST_COLUMN + 1,
+                width: 1,
+                height: 10,
+            },
+            10,
+        ),
+        Err("Invalid column: '16385'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: LAST_COLUMN - 2,
+                width: 10,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid column: '16391'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 5,
+                column: 1,
+                width: 1,
+                height: 10,
+            },
+            -10,
+        ),
+        Err("Invalid row: '-10'".to_string())
+    );
+}
+
+#[test]
+fn invalid_parameters() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 2,
+            },
+            2,
+        ),
+        Err("Invalid parameters for autofill".to_string())
+    );
+}

base/src/test/user_model/test_defined_names.rs

@@ -0,0 +1,40 @@
+#![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, "$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())
+    );
+
+    // rename it
+    model
+        .update_defined_name("myName", None, "myName", None, "$A$1*2")
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("42".to_string())
+    );
+
+    // delete it
+    model.delete_defined_name("myName", None).unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 7),
+        Ok("#REF!".to_string())
+    );
+}
+
+#[test]
+fn rename_defined_name() {}
+
+#[test]
+fn delete_sheet() {}
+
+#[test]
+fn change_scope() {}

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

@@ -129,3 +129,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

@@ -0,0 +1,42 @@
+#![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);
+    model.new_sheet().unwrap();
+
+    // default sheet has show_grid_lines = true
+    assert_eq!(model.get_show_grid_lines(0), Ok(true));
+
+    // default new sheet has show_grid_lines = true
+    assert_eq!(model.get_show_grid_lines(1), Ok(true));
+
+    // wrong sheet number
+    assert_eq!(
+        model.get_show_grid_lines(2),
+        Err("Invalid sheet index".to_string())
+    );
+
+    // we can set it
+    model.set_show_grid_lines(1, false).unwrap();
+    assert_eq!(model.get_show_grid_lines(1), Ok(false));
+    assert_eq!(model.get_show_grid_lines(0), Ok(true));
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_show_grid_lines(1), Ok(true));
+    assert_eq!(model.get_show_grid_lines(0), Ok(true));
+
+    model.redo().unwrap();
+
+    let send_queue = model.flush_send_queue();
+    let mut model2 = UserModel::from_model(new_empty_model());
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(model2.get_show_grid_lines(1), Ok(false));
+    assert_eq!(model2.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_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
@@ -111,6 +115,8 @@ pub struct Worksheet {
     pub frozen_rows: i32,
     pub frozen_columns: i32,
     pub views: HashMap<u32, WorksheetView>,
+    /// Whether or not to show the grid lines in the worksheet
+    pub show_grid_lines: bool,
 }
 
 /// Internal representation of Excel's sheet_data
@@ -572,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(
@@ -303,6 +309,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,183 @@
+use std::collections::HashMap;
+
+use bitcode::{Decode, Encode};
+
+use crate::types::{Cell, Col, Row, 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,
+    },
+    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,
+}

base/src/user_model/mod.rs

@@ -0,0 +1,14 @@
+#![deny(missing_docs)]
+
+mod border_utils;
+mod common;
+mod history;
+mod ui;
+
+pub use common::UserModel;
+
+#[cfg(test)]
+pub use ui::SelectedView;
+
+pub use common::BorderArea;
+pub use common::ClipboardData;

base/src/user_model/ui.rs

@@ -0,0 +1,687 @@
+#![deny(missing_docs)]
+
+use serde::{Deserialize, Serialize};
+
+use crate::expressions::utils::{is_valid_column_number, is_valid_row};
+
+use super::common::UserModel;
+
+#[derive(Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq, Debug))]
+pub struct SelectedView {
+    pub sheet: u32,
+    pub row: i32,
+    pub column: i32,
+    pub range: [i32; 4],
+    pub top_row: i32,
+    pub left_column: i32,
+}
+
+impl UserModel {
+    /// Returns the selected sheet index
+    pub fn get_selected_sheet(&self) -> u32 {
+        if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        }
+    }
+
+    /// Returns the selected cell
+    pub fn get_selected_cell(&self) -> (u32, i32, i32) {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+        if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+            if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                return (sheet, view.row, view.column);
+            }
+        }
+        // return a safe default
+        (0, 1, 1)
+    }
+
+    /// Returns selected view
+    pub fn get_selected_view(&self) -> SelectedView {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+        if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+            if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                return SelectedView {
+                    sheet,
+                    row: view.row,
+                    column: view.column,
+                    range: view.range,
+                    top_row: view.top_row,
+                    left_column: view.left_column,
+                };
+            }
+        }
+        // return a safe default
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 1,
+            left_column: 1,
+        }
+    }
+
+    /// Sets the the selected sheet
+    pub fn set_selected_sheet(&mut self, sheet: u32) -> Result<(), String> {
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Some(view) = self.model.workbook.views.get_mut(&0) {
+            view.sheet = sheet;
+        }
+        Ok(())
+    }
+
+    /// Sets the selected cell for the current view. Note that this also sets the selected range
+    pub fn set_selected_cell(&mut self, row: i32, column: i32) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+        if !is_valid_column_number(column) {
+            return Err(format!("Invalid column: '{column}'"));
+        }
+        if !is_valid_row(row) {
+            return Err(format!("Invalid row: '{row}'"));
+        }
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&0) {
+                view.row = row;
+                view.column = column;
+                view.range = [row, column, row, column];
+            }
+        }
+        Ok(())
+    }
+
+    /// Sets the selected range. Note that the selected cell must be in one of the corners.
+    pub fn set_selected_range(
+        &mut self,
+        start_row: i32,
+        start_column: i32,
+        end_row: i32,
+        end_column: i32,
+    ) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+
+        if !is_valid_column_number(start_column) {
+            return Err(format!("Invalid column: '{start_column}'"));
+        }
+        if !is_valid_row(start_row) {
+            return Err(format!("Invalid row: '{start_row}'"));
+        }
+
+        if !is_valid_column_number(end_column) {
+            return Err(format!("Invalid column: '{end_column}'"));
+        }
+        if !is_valid_row(end_row) {
+            return Err(format!("Invalid row: '{end_row}'"));
+        }
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&0) {
+                let selected_row = view.row;
+                let selected_column = view.column;
+                // The selected cells must be on one of the corners of the selected range:
+                if selected_row != start_row && selected_row != end_row {
+                    return Err(format!(
+                        "The selected cells is not in one of the corners. Row: '{}' and row range '({}, {})'",
+                        selected_row, start_row, end_row
+                    ));
+                }
+                if selected_column != start_column && selected_column != end_column {
+                    return Err(format!(
+                        "The selected cells is not in one of the corners. Column '{}' and column range '({}, {})'",
+                        selected_column, start_column, end_column
+                    ));
+                }
+                view.range = [start_row, start_column, end_row, end_column];
+            }
+        }
+        Ok(())
+    }
+
+    /// The selected range is expanded with the keyboard
+    pub fn on_expand_selected_range(&mut self, key: &str) -> Result<(), String> {
+        let (sheet, window_width, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (
+                    view.sheet,
+                    view.window_width as f64,
+                    view.window_height as f64,
+                )
+            } else {
+                return Ok(());
+            };
+        let (selected_row, selected_column, range, top_row, left_column) =
+            if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+                if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                    (
+                        view.row,
+                        view.column,
+                        view.range,
+                        view.top_row,
+                        view.left_column,
+                    )
+                } else {
+                    return Ok(());
+                }
+            } else {
+                return Ok(());
+            };
+        let [row_start, column_start, row_end, column_end] = range;
+
+        match key {
+            "ArrowRight" => {
+                if selected_column > column_start {
+                    let new_column = column_start + 1;
+                    if !(is_valid_column_number(new_column)) {
+                        return Ok(());
+                    }
+                    self.set_selected_range(row_start, new_column, row_end, column_end)?;
+                } else {
+                    let new_column = column_end + 1;
+                    if !is_valid_column_number(new_column) {
+                        return Ok(());
+                    }
+                    // if the column is not fully visible we 'scroll' right until it is
+                    let mut width = 0.0;
+                    let mut c = left_column;
+                    while c <= new_column {
+                        width += self.model.get_column_width(sheet, c)?;
+                        c += 1;
+                    }
+                    if width > window_width {
+                        self.set_top_left_visible_cell(top_row, left_column + 1)?;
+                    }
+                    self.set_selected_range(row_start, column_start, row_end, column_end + 1)?;
+                }
+            }
+            "ArrowLeft" => {
+                if selected_column < column_end {
+                    let new_column = column_end - 1;
+                    if !is_valid_column_number(new_column) {
+                        return Ok(());
+                    }
+                    if new_column < left_column {
+                        self.set_top_left_visible_cell(top_row, new_column)?;
+                    }
+                    self.set_selected_range(row_start, column_start, row_end, new_column)?;
+                } else {
+                    let new_column = column_start - 1;
+                    if !is_valid_column_number(new_column) {
+                        return Ok(());
+                    }
+                    if new_column < left_column {
+                        self.set_top_left_visible_cell(top_row, new_column)?;
+                    }
+                    self.set_selected_range(row_start, new_column, row_end, column_end)?;
+                }
+            }
+            "ArrowUp" => {
+                if selected_row < row_end {
+                    let new_row = row_end - 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    self.set_selected_range(row_start, column_start, new_row, column_end)?;
+                } else {
+                    let new_row = row_start - 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    if new_row < top_row {
+                        self.set_top_left_visible_cell(new_row, left_column)?;
+                    }
+                    self.set_selected_range(new_row, column_start, row_end, column_end)?;
+                }
+            }
+            "ArrowDown" => {
+                if selected_row > row_start {
+                    let new_row = row_start + 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    self.set_selected_range(new_row, column_start, row_end, column_end)?;
+                } else {
+                    let new_row = row_end + 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    let mut height = 0.0;
+                    let mut r = top_row;
+                    while r <= new_row + 1 {
+                        height += self.model.get_row_height(sheet, r)?;
+                        r += 1;
+                    }
+                    if height >= window_height {
+                        self.set_top_left_visible_cell(top_row + 1, left_column)?;
+                    }
+                    self.set_selected_range(row_start, column_start, new_row, column_end)?;
+                }
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+
+    /// Sets the value of the first visible cell
+    pub fn set_top_left_visible_cell(
+        &mut self,
+        top_row: i32,
+        left_column: i32,
+    ) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+
+        if !is_valid_column_number(left_column) {
+            return Err(format!("Invalid column: '{left_column}'"));
+        }
+        if !is_valid_row(top_row) {
+            return Err(format!("Invalid row: '{top_row}'"));
+        }
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&0) {
+                view.top_row = top_row;
+                view.left_column = left_column;
+            }
+        }
+        Ok(())
+    }
+
+    /// Sets the width of the window
+    pub fn set_window_width(&mut self, window_width: f64) {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            view.window_width = window_width as i64;
+        };
+    }
+
+    /// Gets the width of the window
+    pub fn get_window_width(&mut self) -> Result<i64, String> {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            return Ok(view.window_width);
+        };
+        Err("View not found".to_string())
+    }
+
+    /// Sets the height of the window
+    pub fn set_window_height(&mut self, window_height: f64) {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            view.window_height = window_height as i64;
+        };
+    }
+
+    /// Gets the height of the window
+    pub fn get_window_height(&mut self) -> Result<i64, String> {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            return Ok(view.window_height);
+        };
+        Err("View not found".to_string())
+    }
+
+    /// User presses right arrow
+    pub fn on_arrow_right(&mut self) -> Result<(), String> {
+        let (sheet, window_width) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_width)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_column = view.column + 1;
+        if !is_valid_column_number(new_column) {
+            return Ok(());
+        }
+        // if the column is not fully visible we 'scroll' right until it is
+        let mut width = 0.0;
+        let mut column = view.left_column;
+        while column <= new_column {
+            width += self.model.get_column_width(sheet, column)?;
+            column += 1;
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.column = new_column;
+                view.range = [view.row, new_column, view.row, new_column];
+                if width > window_width as f64 {
+                    view.left_column += 1;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// User presses left arrow
+    pub fn on_arrow_left(&mut self) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_column = view.column - 1;
+        if !is_valid_column_number(new_column) {
+            return Ok(());
+        }
+        // if the column is not fully visible we 'scroll' right until it is
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.column = new_column;
+                view.range = [view.row, new_column, view.row, new_column];
+                if new_column < view.left_column {
+                    view.left_column = new_column;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// User presses up arrow key
+    pub fn on_arrow_up(&mut self) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_row = view.row - 1;
+        if !is_valid_row(new_row) {
+            return Ok(());
+        }
+        // if the column is not fully visible we 'scroll' right until it is
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.row = new_row;
+                view.range = [new_row, view.column, new_row, view.column];
+                if new_row < view.top_row {
+                    view.top_row = new_row;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// User presses down arrow key
+    pub fn on_arrow_down(&mut self) -> Result<(), String> {
+        let (sheet, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_height)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_row = view.row + 1;
+        if !is_valid_row(new_row) {
+            return Ok(());
+        }
+        // if the row is not fully visible we 'scroll' down until it is
+        let mut height = 0.0;
+        let mut row = view.top_row;
+        while row <= new_row + 1 {
+            height += self.model.get_row_height(sheet, row)?;
+            row += 1;
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.row = new_row;
+                view.range = [new_row, view.column, new_row, view.column];
+                if height > window_height as f64 {
+                    view.top_row += 1;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // TODO: This function should be memoized
+    /// Returns the x-coordinate of the cell in the top left corner
+    pub fn get_scroll_x(&self) -> Result<f64, String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let mut scroll_x = 0.0;
+        for column in 1..view.left_column {
+            scroll_x += self.model.get_column_width(sheet, column)?;
+        }
+        Ok(scroll_x)
+    }
+
+    // TODO: This function should be memoized
+    /// Returns the y-coordinate of the cell in the top left corner
+    pub fn get_scroll_y(&self) -> Result<f64, String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let mut scroll_y = 0.0;
+        for row in 1..view.top_row {
+            scroll_y += self.model.get_row_height(sheet, row)?;
+        }
+        Ok(scroll_y)
+    }
+
+    /// User presses page down.
+    /// The `top_row` is now the first row that is not fully visible
+    pub fn on_page_down(&mut self) -> Result<(), String> {
+        let (sheet, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_height)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let mut last_row = view.top_row;
+        let mut height = self.model.get_row_height(sheet, last_row)?;
+        while height <= window_height as f64 {
+            last_row += 1;
+            height += self.model.get_row_height(sheet, last_row)?;
+        }
+        if !is_valid_row(last_row) {
+            return Ok(());
+        }
+        let row_delta = view.row - view.top_row;
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.top_row = last_row;
+                view.row = view.top_row + row_delta;
+                view.range = [view.row, view.column, view.row, view.column];
+            }
+        }
+        Ok(())
+    }
+
+    /// On page up. tis needs to be the inverse of page down
+    pub fn on_page_up(&mut self) -> Result<(), String> {
+        let (sheet, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_height as f64)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+
+        let mut first_row = view.top_row;
+        let mut height = self.model.get_row_height(sheet, first_row)?;
+        while height <= window_height && first_row > 1 {
+            first_row -= 1;
+            height += self.model.get_row_height(sheet, first_row)?;
+        }
+
+        let row_delta = view.row - view.top_row;
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.top_row = first_row;
+                view.row = view.top_row + row_delta;
+                view.range = [view.row, view.column, view.row, view.column];
+            }
+        }
+        Ok(())
+    }
+
+    /// We extend the selection to cell (target_row, target_column)
+    pub fn on_area_selecting(&mut self, target_row: i32, target_column: i32) -> Result<(), String> {
+        let (sheet, window_width, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (
+                    view.sheet,
+                    view.window_width as f64,
+                    view.window_height as f64,
+                )
+            } else {
+                return Ok(());
+            };
+        let (selected_row, selected_column, range, top_row, left_column) =
+            if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+                if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                    (
+                        view.row,
+                        view.column,
+                        view.range,
+                        view.top_row,
+                        view.left_column,
+                    )
+                } else {
+                    return Ok(());
+                }
+            } else {
+                return Ok(());
+            };
+        let [row_start, column_start, _row_end, _column_end] = range;
+
+        let mut new_left_column = left_column;
+        if target_column >= selected_column {
+            let mut width = 0.0;
+            let mut column = left_column;
+            while column <= target_column {
+                width += self.model.get_column_width(sheet, column)?;
+                column += 1;
+            }
+
+            while width > window_width {
+                width -= self.model.get_column_width(sheet, new_left_column)?;
+                new_left_column += 1;
+            }
+        } else if target_column < new_left_column {
+            new_left_column = target_column;
+        }
+        let mut new_top_row = top_row;
+        if target_row >= selected_row {
+            let mut height = 0.0;
+            let mut row = top_row;
+            while row <= target_row {
+                height += self.model.get_row_height(sheet, row)?;
+                row += 1;
+            }
+            while height > window_height {
+                height -= self.model.get_row_height(sheet, new_top_row)?;
+                new_top_row += 1;
+            }
+        } else if target_row < new_top_row {
+            new_top_row = target_row;
+        }
+
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.range = [row_start, column_start, target_row, target_column];
+                if new_top_row != top_row {
+                    view.top_row = new_top_row;
+                }
+                if new_left_column != left_column {
+                    view.left_column = new_left_column;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

base/src/utils.rs

@@ -34,6 +34,7 @@ impl ParsedReference {
         locale: &Locale,
         get_sheet_index_by_name: F,
     ) -> Result<ParsedReference, String> {
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("");
         let mut lexer = Lexer::new(reference, LexerMode::A1, locale, language);
 
@@ -151,6 +152,8 @@ pub(crate) fn is_valid_hex_color(color: &str) -> bool {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::expect_used)]
+
     use super::*;
     use crate::language::get_language;
     use crate::locale::{get_locale, Locale};