adding merge cell logic processing

formatting commit

addressing testcase failures

adding one more scenario to case

adding one more scenario to case

Adding update and unmerge functions for merge cell handling

adding one more case to testcase

adding testcases to base code

adding testcase for import/export

adding documentation to some of the PUB function

fixing warnings and test warnings

adding merge cell part cell update restriction to public sytle set fns

addressing reviwers comment : Changed Mergedcell structure and its side effercts

reverting it back to non pub.

renaming update_merge_cells to just merge_cells in model

renaming *unmerge_merged_cell* to *unmerge_cells*

addressing other reviewer's comment + cosmetica naming adjustments

cosmetic changes

.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,10 @@
 name: Coverage
 
-on: [pull_request, push]
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
 jobs:
   coverage:
@@ -14,7 +18,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:

.gitignore

@@ -1 +1,2 @@
 target/*
+.DS_Store

.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,26 @@
+# 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
+
+## [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,19 +405,20 @@ 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",
- "serde_repr",
 ]
 
 [[package]]
@@ -424,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"
@@ -456,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",
 ]
@@ -530,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"
@@ -544,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"
@@ -613,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"
@@ -679,17 +821,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_repr"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b2e6b945e9d3df726b65d6ee24060aff8e3533d431f677a9695db04eff9dfdb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "sha1"
 version = "0.10.6"
@@ -726,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"
@@ -786,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,49 +1,44 @@
-all:
-	cargo build --release
-	cd bindings/wasm/ && make
-	cd webapp && npm install && npm run build
-
+.PHONY: lint
 lint:
 	cargo fmt -- --check
-	# TODO: See issue #33
-	# cargo clippy --all-targets --all-features -- -D warnings -D clippy::expect_used -D clippy::unwrap_used -D clippy::panic
-	cargo clippy --all-targets --all-features -- -D warnings
+	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/ && make tests
+	# 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-*
-	rm -r -f webapp/node_modules
-
 
+.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:
-	cargo build
-	./target/debug/documentation -o wiki/functions.md
-
+.PHONY: docs
 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.
 

assets/icon/ironcalc_icon.svg

@@ -0,0 +1,8 @@
+<svg width="600" height="600" viewBox="0 0 600 600" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="600" height="600" rx="20" fill="#F2994A"/>
+<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M348.98 100C348.98 166.034 322.748 229.362 276.055 276.055C268.163 283.947 259.796 291.255 251.021 297.95L251.021 500L348.98 500H251.021C251.021 433.966 277.252 370.637 323.945 323.945C331.837 316.053 340.204 308.745 348.98 302.05L348.98 100Z" fill="white"/>
+<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M251.021 100.068C251.003 140.096 235.094 178.481 206.788 206.787C178.466 235.109 140.053 251.02 100 251.02V348.979C154.873 348.979 207.877 330.866 251.021 297.95V100.068Z" fill="white"/>
+<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M348.98 499.882C349.011 459.872 364.918 421.507 393.213 393.213C421.534 364.891 459.947 348.98 500 348.98V251.02C445.128 251.02 392.123 269.134 348.98 302.05V499.882Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M276.055 276.055C322.748 229.362 348.98 166.034 348.98 100H251.021V297.95C259.796 291.255 268.163 283.947 276.055 276.055Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M348.98 302.05V499.895C348.98 499.93 348.98 499.965 348.98 500L251.021 500C251.021 499.946 251.02 499.891 251.021 499.837C251.064 433.862 277.291 370.599 323.945 323.945C331.837 316.053 340.204 308.745 348.98 302.05Z" fill="white"/>
+</svg>

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"
@@ -12,14 +12,22 @@ readme = "README.md"
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-serde_repr = "0.1"
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.9"
-regex = "1.0"
+chrono-tz = "0.10"
+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"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 js-sys = { version = "0.3.69" }

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);
-        self.cell_clear_all(sheet, source_row, source_column)?;
-        Ok(())
+            .set_cell_style(target_row, target_column, style)?;
+        self.cell_clear_all(sheet, source_row, source_column)
     }
 
     /// Inserts one or more new columns into the model at the specified index.

base/src/cell.rs

@@ -1,12 +1,9 @@
 use crate::{
     expressions::token::Error, language::Language, number_format::to_excel_precision_str, types::*,
 };
-use serde::{Deserialize, Serialize};
-use serde_json::json;
 
 /// A CellValue is the representation of the cell content.
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
-#[serde(untagged)]
+#[derive(Debug, PartialEq)]
 pub enum CellValue {
     None,
     String(String),
@@ -14,17 +11,6 @@ pub enum CellValue {
     Boolean(bool),
 }
 
-impl CellValue {
-    pub fn to_json_str(&self) -> String {
-        match &self {
-            CellValue::None => "null".to_string(),
-            CellValue::String(s) => json!(s).to_string(),
-            CellValue::Number(f) => json!(f).to_string(),
-            CellValue::Boolean(b) => json!(b).to_string(),
-        }
-    }
-}
-
 impl From<f64> for CellValue {
     fn from(value: f64) -> Self {
         Self::Number(value)
@@ -190,3 +176,18 @@ impl Cell {
         }
     }
 }
+
+// Implementing methods for MergedCells struct
+
+impl MergedCells {
+    pub fn is_cell_part_of_merged_cells(&self, row: i32, col: i32) -> bool {
+        // This is merge Mother cell so do not include this cell as part of Merged Cells
+        if row == self.0 && col == self.1 {
+            return false;
+        }
+
+        let result: bool = (row >= self.0 && row <= self.2) && (col >= self.1 && col <= self.3);
+
+        result
+    }
+}

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_ROW_HEIGHT: f64 = 21.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.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_HEIGH: 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},

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

@@ -63,7 +63,9 @@ 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 +204,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 {
@@ -222,7 +226,7 @@ impl Parser {
 
     pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
         self.lexer.set_formula(formula);
-        self.context = context.clone();
+        self.context.clone_from(context);
         self.parse_expr()
     }
 
@@ -675,14 +679,23 @@ impl Parser {
                         }
                     };
                     // table-name => table
-                    let table = self.tables.get(&table_name).unwrap_or_else(|| {
-                        panic!(
+                    let table = match self.tables.get(&table_name) {
+                        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 +714,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/test.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::panic)]
+
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;

base/src/expressions/token.rs

@@ -2,7 +2,6 @@ use std::fmt;
 
 use bitcode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
-use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::language::Language;
 
@@ -81,8 +80,7 @@ impl fmt::Display for OpProduct {
 ///  * "#ERROR!" means there was an error processing the formula (for instance "=A1+")
 ///  * "#N/IMPL!" means the formula or feature in Excel but has not been implemented in IronCalc
 ///    Note that they are serialized/deserialized by index
-#[derive(Serialize_repr, Deserialize_repr, Encode, Decode, Debug, PartialEq, Eq, Clone)]
-#[repr(u8)]
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Error {
     REF,
     NAME,

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

@@ -194,16 +194,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
-    // They are really similar expect for small issues
-    fn get_array_of_numbers(
+    fn get_array_of_numbers_generic(
         &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 +220,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 +228,46 @@ impl Model {
                 if row1 == 1 && row2 == LAST_ROW {
                     row2 = self
                         .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .worksheet(sheet)
+                        .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)
-                        .expect("Sheet expected during evaluation.")
+                        .worksheet(sheet)
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{}'", sheet),
+                            )
+                        })?
                         .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) => {
+                for row in row1..=row2 {
+                    for column in column1..=column2 {
+                        let cell_ref = CellReferenceIndex { sheet, row, column };
+                        match self.evaluate_cell(cell_ref) {
+                            CalcResult::Number(value) => values.push(value),
+                            error @ CalcResult::Error { .. } => return Err(error),
+                            CalcResult::EmptyCell => {
+                                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 +275,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();
-        match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) => values.push(value),
-            CalcResult::Range { left, right } => {
-                if left.sheet != right.sheet {
-                    return 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(
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            true, // accept_number_node
+            || {
+                Err(CalcResult::new_error(
                     Error::NUM,
                     *cell,
                     "Expected number".to_string(),
-                                ));
-                            }
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    error,
+                ))
+            },
+            || {
+                Err(CalcResult::new_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 +327,19 @@ impl Model {
         arg: &Node,
         cell: &CellReferenceIndex,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
-        match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Range { left, right } => {
-                if left.sheet != right.sheet {
-                    return 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 => values.push(0.0),
-                            _ => {
-                                return Err(CalcResult::new_error(
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            false,            // Do not accept a single number node
+            || Ok(Some(0.0)), // Treat empty cells as zero
+            || {
+                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 +798,28 @@ impl Model {
                     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;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -1393,21 +1337,21 @@ impl Model {
         CalcResult::Number(result)
     }
 
-    /// This next three functions deal with Treasure Bills or T-Bills for short
-    /// They are zero-coupon that mature in one year or less.
-    ///  Definitions:
-    ///    $r$ be the discount rate
-    ///    $v$ the face value of the Bill
-    ///    $p$ the price of the Bill
-    ///    $d_m$ is the number of days from the settlement to maturity
-    /// Then:
-    ///   $$ 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:
-    /// $$ 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.
-    /// 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) $$
-    /// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
+    // This next three functions deal with Treasure Bills or T-Bills for short
+    // They are zero-coupon that mature in one year or less.
+    //  Definitions:
+    //    $r$ be the discount rate
+    //    $v$ the face value of the Bill
+    //    $p$ the price of the Bill
+    //    $d_m$ is the number of days from the settlement to maturity
+    // Then:
+    //   $$ 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:
+    // $$ 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.
+    // 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) $$
+    // 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/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
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    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
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    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,
@@ -246,7 +248,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 192> {
+    pub fn into_iter() -> IntoIter<Function, 194> {
         [
             Function::And,
             Function::False,
@@ -316,6 +318,7 @@ impl Function {
             Function::Search,
             Function::Text,
             Function::Trim,
+            Function::Unicode,
             Function::Upper,
             Function::Isnumber,
             Function::Isnontext,
@@ -330,6 +333,7 @@ impl Function {
             Function::Isodd,
             Function::Iseven,
             Function::ErrorType,
+            Function::Formulatext,
             Function::Isformula,
             Function::Type,
             Function::Sheet,
@@ -460,6 +464,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 +484,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 +573,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 +595,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),
@@ -779,6 +787,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 +802,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"),
@@ -1012,6 +1022,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 +1038,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),
@@ -1148,6 +1160,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
-            .workbook
-            .worksheet(first_range.left.sheet)
-            .expect("Sheet expected during evaluation.")
-            .dimension();
+        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
+            Ok(s) => s.dimension(),
+            Err(_) => {
+                return CalcResult::new_error(
+                    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
-                .workbook
-                .worksheet(sum_range.left.sheet)
-                .expect("Sheet expected during evaluation.")
-                .dimension()
-                .max_row;
+            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_row,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
         if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = self
-                .workbook
-                .worksheet(sum_range.left.sheet)
-                .expect("Sheet expected during evaluation.")
-                .dimension()
-                .max_column;
+            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_column,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
 
         for row in left_row..right_row + 1 {

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 {
-        let worksheet = self.workbook.worksheet(sheet_index).expect("");
+    fn cell_hidden_status(
+        &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
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    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.
-/// 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.
+// 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
+// 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
-                                .workbook
-                                .worksheet(left.sheet)
-                                .expect("Sheet expected during evaluation.")
-                                .dimension()
-                                .max_row;
+                            row2 = match self.workbook.worksheet(left.sheet) {
+                                Ok(s) => s.dimension().max_row,
+                                Err(_) => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         if column1 == 1 && column2 == LAST_COLUMN {
-                            column2 = self
-                                .workbook
-                                .worksheet(left.sheet)
-                                .expect("Sheet expected during evaluation.")
-                                .dimension()
-                                .max_column;
+                            column2 = match self.workbook.worksheet(left.sheet) {
+                                Ok(s) => s.dimension().max_column,
+                                Err(_) => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         let left = CellReferenceIndex {
                             sheet: left.sheet,

base/src/language/language.bin

@@ -0,0 +1 @@
+PfrendeesD<>VRAITRUEWAHRVERDADEROTVFAUXFALSEFALSCHFALSOUw#REF!#REF!#BEZUG!#¡REF!e<>#NOM?#NAME?#NAME?#¿NOMBRE?x<>#VALEUR!#VALUE!#WERT!#¡VALOR!w<>#DIV/0!#DIV/0!#DIV/0!#¡DIV/0!<04>#N/A#N/A#NV#N/AXv#NOMBRE!#NUM!#ZAHL!#¡NUM!<02><>#N/IMPL!#N/IMPL!#N/IMPL!#N/IMPL!w{#SPILL!#SPILL!#ÜBERLAUF!#SPILL!ff#CALC!#CALC!#CALC!#CALC!ff#CIRC!#CIRC!#CIRC!#CIRC!ww#ERROR!#ERROR!#ERROR!#ERROR!ff#NULL!#NULL!#NULL!#NULL!

base/src/language/mod.rs

@@ -1,15 +1,15 @@
-use once_cell::sync::Lazy;
-use serde::{Deserialize, Serialize};
-
 use std::collections::HashMap;
 
-#[derive(Serialize, Deserialize, Clone)]
+use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
+
+#[derive(Encode, Decode, Clone)]
 pub struct Booleans {
     pub r#true: String,
     pub r#false: String,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Errors {
     pub r#ref: String,
     pub name: String,
@@ -25,14 +25,15 @@ pub struct Errors {
     pub null: String,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Language {
     pub booleans: Booleans,
     pub errors: Errors,
 }
 
+#[allow(clippy::expect_used)]
 static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
-    serde_json::from_str(include_str!("language.json")).expect("Failed parsing language file")
+    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
 });
 
 pub fn get_language(id: &str) -> Result<&Language, String> {

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

@@ -1,32 +1,29 @@
+use bitcode::{Decode, Encode};
 use once_cell::sync::Lazy;
-use serde::{Deserialize, Serialize};
 
 use std::collections::HashMap;
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Locale {
     pub dates: Dates,
     pub numbers: NumbersProperties,
     pub currency: Currency,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Currency {
     pub iso: String,
     pub symbol: String,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct NumbersProperties {
-    #[serde(rename = "symbols-numberSystem-latn")]
     pub symbols: NumbersSymbols,
-    #[serde(rename = "decimalFormats-numberSystem-latn")]
     pub decimal_formats: DecimalFormats,
-    #[serde(rename = "currencyFormats-numberSystem-latn")]
     pub currency_formats: CurrencyFormats,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Dates {
     pub day_names: Vec<String>,
     pub day_names_short: Vec<String>,
@@ -35,8 +32,7 @@ pub struct Dates {
     pub months_letter: Vec<String>,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
+#[derive(Encode, Decode, Clone)]
 pub struct NumbersSymbols {
     pub decimal: String,
     pub group: String,
@@ -54,31 +50,24 @@ pub struct NumbersSymbols {
 }
 
 // See: https://cldr.unicode.org/translation/number-currency-formats/number-and-currency-patterns
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct CurrencyFormats {
     pub standard: String,
-    #[serde(rename = "standard-alphaNextToNumber")]
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub standard_alpha_next_to_number: Option<String>,
-    #[serde(rename = "standard-noCurrency")]
     pub standard_no_currency: String,
     pub accounting: String,
-    #[serde(rename = "accounting-alphaNextToNumber")]
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub accounting_alpha_next_to_number: Option<String>,
-    #[serde(rename = "accounting-noCurrency")]
     pub accounting_no_currency: String,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
+#[derive(Encode, Decode, Clone)]
 pub struct DecimalFormats {
     pub standard: String,
 }
 
-static LOCALES: Lazy<HashMap<String, Locale>> = Lazy::new(|| {
-    serde_json::from_str(include_str!("locales.json")).expect("Failed parsing locale")
-});
+#[allow(clippy::expect_used)]
+static LOCALES: Lazy<HashMap<String, Locale>> =
+    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
 
 pub fn get_locale(id: &str) -> Result<&Locale, String> {
     // TODO: pass the locale once we implement locales in Rust

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, parse_reference_a1},
     },
     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()
@@ -118,6 +115,8 @@ pub struct Model {
     pub(crate) language: Language,
     /// The timezone used to evaluate the model
     pub(crate) tz: Tz,
+    /// The view id. A view consist of a selected sheet and ranges.
+    pub(crate) view_id: u32,
 }
 
 // FIXME: Maybe this should be the same as CellReference
@@ -531,6 +530,7 @@ impl Model {
         }
     }
 
+    #[allow(clippy::expect_used)]
     fn cell_reference_to_string(
         &self,
         cell_reference: &CellReferenceIndex,
@@ -546,6 +546,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];
@@ -681,6 +682,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 {
@@ -739,6 +747,29 @@ impl Model {
         self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
     }
 
+    /// Returns 'true' if the cell belongs to any Merged cells
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ironcalc_base::Model;
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
+    /// model.merge_cells(0, "A1:D5");
+    /// assert_eq!(model.is_part_of_merged_cells(0, 1, 2)?, true);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn is_part_of_merged_cells(
+        &self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<bool, String> {
+        self.workbook
+            .worksheet(sheet)?
+            .is_part_of_merged_cells(row, column)
+    }
+
     pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
         let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
             .sheet_data
@@ -870,6 +901,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() {
@@ -886,6 +918,7 @@ impl Model {
             language,
             locale,
             tz,
+            view_id: 0,
         };
 
         model.parse_formulas();
@@ -1194,10 +1227,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(())
     /// # }
@@ -1208,23 +1241,38 @@ 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) {
-        let style_index = self.get_cell_style_index(sheet, row, column);
+    pub fn update_cell_with_text(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: &str,
+    ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
+        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
@@ -1237,10 +1285,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(())
     /// # }
@@ -1251,17 +1299,31 @@ 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) {
-        let style_index = self.get_cell_style_index(sheet, row, column);
+    pub fn update_cell_with_bool(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: bool,
+    ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
+
+        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];
-        worksheet.set_cell_with_boolean(row, column, value, new_style_index);
+        self.set_cell_with_boolean(sheet, row, column, value, new_style_index)
     }
 
     /// Updates the value of a cell with a number
@@ -1274,10 +1336,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(())
     /// # }
@@ -1288,17 +1350,30 @@ 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) {
-        let style_index = self.get_cell_style_index(sheet, row, column);
+    pub fn update_cell_with_number(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: f64,
+    ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
+        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];
-        worksheet.set_cell_with_number(row, column, value, new_style_index);
+        self.set_cell_with_number(sheet, row, column, value, new_style_index)
     }
 
     /// Updates the formula of given cell
@@ -1312,11 +1387,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(())
@@ -1335,12 +1410,18 @@ impl Model {
         column: i32,
         formula: String,
     ) -> Result<(), String> {
-        let mut style_index = self.get_cell_style_index(sheet, row, column);
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                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('=')
@@ -1380,31 +1461,44 @@ 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> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         // 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
-                    .set_cell_with_formula(sheet, row, column, formula, new_style_index)
-                    .expect("could not set the cell formula");
+                let formula_index =
+                    self.set_cell_with_formula(sheet, row, column, formula, new_style_index)?;
                 // Update the style if needed
                 let cell = CellReferenceIndex { sheet, row, column };
                 let parsed_formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
@@ -1412,15 +1506,11 @@ impl Model {
                     let new_style_index = self
                         .workbook
                         .styles
-                        .get_style_with_format(new_style_index, &units.get_num_fmt());
-                    let style = self.workbook.styles.get_style(new_style_index);
-                    self.set_cell_style(sheet, row, column, &style)
-                        .expect("Failed setting the style");
+                        .get_style_with_format(new_style_index, &units.get_num_fmt())?;
+                    let style = self.workbook.styles.get_style(new_style_index)?;
+                    self.set_cell_style(sheet, row, column, &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;
@@ -1433,35 +1523,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);
-                    return;
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
+                    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);
-                    return;
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
+                    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(
@@ -1502,24 +1596,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) {
-        let worksheets = &mut self.workbook.worksheets;
-        let worksheet = &mut worksheets[sheet as usize];
+    fn set_cell_with_string(
+        &mut self,
+        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
@@ -1586,7 +1722,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
@@ -1689,7 +1825,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(())
     }
 
@@ -1724,43 +1860,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
-            .workbook
-            .worksheet(sheet)
-            .expect("Invalid sheet")
-            .cell(row, column);
+        let cell = self.workbook.worksheet(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 {
-        self.workbook
-            .styles
-            .get_style(self.get_cell_style_index(sheet, row, column))
+    pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
+        let style = self.workbook.styles.get_style(style_index)?;
+        Ok(style)
     }
 
     /// Returns an internal binary representation of the workbook
@@ -1800,7 +1933,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}**")
                 }
@@ -1857,6 +1990,7 @@ impl Model {
     /// Sets the number of frozen rows to `frozen_rows` in the workbook.
     /// Fails if `frozen`_rows` is either too small (<0) or too large (>LAST_ROW)`
     pub fn set_frozen_rows(&mut self, sheet: u32, frozen_rows: i32) -> Result<(), String> {
+        // TODO: What is frozen rows and do we need to take of this if row we are frozing is part of merge cells ?
         if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
             if frozen_rows < 0 {
                 return Err("Frozen rows cannot be negative".to_string());
@@ -1874,6 +2008,7 @@ impl Model {
     /// Sets the number of frozen columns to `frozen_column` in the workbook.
     /// Fails if `frozen`_columns` is either too small (<0) or too large (>LAST_COLUMN)`
     pub fn set_frozen_columns(&mut self, sheet: u32, frozen_columns: i32) -> Result<(), String> {
+        // TODO: What is frozen columns and do we need to take of this if column we are frozing is part of merge cells ?
         if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
             if frozen_columns < 0 {
                 return Err("Frozen columns cannot be negative".to_string());
@@ -1915,10 +2050,169 @@ impl Model {
             .worksheet_mut(sheet)?
             .set_row_height(column, height)
     }
+
+    fn parse_merged_range(&mut self, range: &str) -> Result<(i32, i32, i32, i32), String> {
+        let parts: Vec<&str> = range.split(':').collect();
+        if parts.len() == 1 {
+            Err(format!("Invalid range: '{}'", range))
+        } else if parts.len() == 2 {
+            match (parse_reference_a1(parts[0]), parse_reference_a1(parts[1])) {
+                (Some(left), Some(right)) => {
+                    return Ok((left.row, left.column, right.row, right.column));
+                }
+                _ => return Err(format!("Invalid range: '{}'", range)),
+            }
+        } else {
+            return Err(format!("Invalid range: '{}'", range));
+        }
+    }
+
+    // Implementing public APIS related to Merge cells handling
+
+    /// Merges given selected cells
+    /// If no overlap, it will create that merged cells with left most top cell value representing the whole merged cells
+    /// If new merge cells creation overlaps with any of the existing merged cells, Overlapped merged cells gets unmerged
+    /// and new merge cells gets added
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ironcalc_base::Model;
+    /// # use ironcalc_base::cell::CellValue;
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
+    /// model.merge_cells(0, "D4:F6").unwrap();
+    /// model.merge_cells(0, "A1:B4").unwrap();
+    /// assert_eq!(model.workbook.worksheet(0).unwrap().merged_cells_list.len(), 2);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// See also:
+    /// * [Model::update_cell_with_formula()]
+    /// * [Model::update_cell_with_number()]
+    /// * [Model::update_cell_with_bool()]
+    /// * [Model::update_cell_with_text()]
+    pub fn merge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
+        match self.parse_merged_range(range_ref) {
+            Ok(parsed_merge_cell_range) => {
+                // ATTENTION 2: Below thing we can support here but keeping it simple
+                // Web or different client needs to keep this in mind
+                // User can give errored parse ranges like C3:A1
+                // Where col_start and row_start and is greated then col_end and row_end
+                // Return error in these scenario
+                if parsed_merge_cell_range.0 > parsed_merge_cell_range.2
+                    || parsed_merge_cell_range.1 > parsed_merge_cell_range.3
+                {
+                    return Err(
+                        "Invalid parse range. Merge Mother cell always be top left cell"
+                            .to_string(),
+                    );
+                }
+
+                let mut merged_cells_overlaped_list: Vec<bool> = Vec::new();
+                // checking whether our new range overlaps with any of the already existing merged cells
+                // if so, need to unmerge those and create this new one
+                {
+                    let worksheet = self.workbook.worksheet(sheet)?;
+                    let merged_cells = worksheet.get_merged_cells_list();
+
+                    for merge_node in merged_cells {
+                        // checking whether any overlapping exist with this merge cell
+                        if !(parsed_merge_cell_range.1 > merge_node.3
+                            || parsed_merge_cell_range.3 < merge_node.1
+                            || parsed_merge_cell_range.0 > merge_node.2
+                            || parsed_merge_cell_range.2 < merge_node.0)
+                        {
+                            // overlap has happened
+                            merged_cells_overlaped_list.push(true);
+                        } else {
+                            merged_cells_overlaped_list.push(false);
+                        }
+                    }
+                }
+
+                if !merged_cells_overlaped_list.is_empty() {
+                    // Lets take Mutable ref to Merge cell and deletes all those nodes which has overlapped
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
+                    let merged_cells_list_mut = worksheet.get_merged_cells_list_mut();
+                    let mut merged_cells_overlaped_list_iter = merged_cells_overlaped_list.iter();
+                    merged_cells_list_mut
+                        .retain(|_| !(*merged_cells_overlaped_list_iter.next().unwrap()))
+                }
+
+                // Now need to update (n*m - 1) cells with empty cell ( except the Mother cell )
+                for row_index in parsed_merge_cell_range.0..=parsed_merge_cell_range.2 {
+                    for col_index in parsed_merge_cell_range.1..=parsed_merge_cell_range.3 {
+                        // skip Mother cell
+                        if row_index == parsed_merge_cell_range.0
+                            && col_index == parsed_merge_cell_range.2
+                        {
+                            continue;
+                        }
+
+                        //update the node with empty cell
+                        {
+                            self.workbook.worksheet_mut(sheet)?.update_cell(
+                                row_index,
+                                col_index,
+                                Cell::EmptyCell { s: 0 },
+                            )?;
+                        }
+                    }
+                }
+
+                let new_merged_cells = MergedCells::new(parsed_merge_cell_range);
+                {
+                    self.workbook
+                        .worksheet_mut(sheet)?
+                        .merged_cells_list
+                        .push(new_merged_cells);
+                }
+            }
+            Err(err) => {
+                return Err(err);
+            }
+        }
+        Ok(())
+    }
+
+    /// Unmerges a given/selected merged cells
+    /// Once unmerged, only top most left corner value gets retained and all the others will have empty cell
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ironcalc_base::Model;
+    /// # use ironcalc_base::cell::CellValue;
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut model = Model::new_empty("model", "en", "UTC")?;
+    /// model.merge_cells(0, "D4:F6");
+    /// model.unmerge_cells(0, "D4:F6");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn unmerge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
+        let worksheet = self.workbook.worksheet(sheet)?;
+        let merged_cells = worksheet.get_merged_cells_list();
+        for (index, merge_node) in merged_cells.iter().enumerate() {
+            let merge_block_range_ref = merge_node.get_merged_cells_str_ref()?;
+            // finding the merge cell node to be deleted
+            if merge_block_range_ref.as_str() == range_ref {
+                // Merge cell to be deleted is found
+                self.workbook
+                    .worksheet_mut(sheet)?
+                    .merged_cells_list
+                    .remove(index);
+                return Ok(());
+            }
+        }
+        Err("Invalid merge_cell_ref, Merged cells to be deleted is 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,16 +4,21 @@ use std::collections::HashMap;
 
 use crate::{
     calc_result::Range,
+    constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
     expressions::{
         lexer::LexerMode,
-        parser::stringify::{rename_sheet_in_node, to_rc_format},
-        parser::Parser,
+        parser::{
+            stringify::{rename_sheet_in_node, to_rc_format},
+            Parser,
+        },
         types::CellReferenceRC,
     },
     language::get_language,
     locale::get_locale,
     model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
-    types::{Metadata, SheetState, Workbook, WorkbookSettings, Worksheet},
+    types::{
+        Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
+    },
     utils::ParsedReference,
 };
 
@@ -33,13 +38,26 @@ fn is_valid_sheet_name(name: &str) -> bool {
 
 impl Model {
     /// Creates a new worksheet. Note that it does not check if the name or the sheet_id exists
-    fn new_empty_worksheet(name: &str, sheet_id: u32) -> Worksheet {
+    fn new_empty_worksheet(name: &str, sheet_id: u32, view_ids: &[&u32]) -> Worksheet {
+        let mut views = HashMap::new();
+        for id in view_ids {
+            views.insert(
+                **id,
+                WorksheetView {
+                    row: 1,
+                    column: 1,
+                    range: [1, 1, 1, 1],
+                    top_row: 1,
+                    left_column: 1,
+                },
+            );
+        }
         Worksheet {
             cols: vec![],
             rows: vec![],
             comments: vec![],
             dimension: "A1".to_string(),
-            merge_cells: vec![],
+            merged_cells_list: vec![],
             name: name.to_string(),
             shared_formulas: vec![],
             sheet_data: Default::default(),
@@ -48,6 +66,8 @@ impl Model {
             color: Default::default(),
             frozen_columns: 0,
             frozen_rows: 0,
+            show_grid_lines: true,
+            views,
         }
     }
 
@@ -122,7 +142,7 @@ impl Model {
         self.parsed_defined_names = parsed_defined_names;
     }
 
-    // Reparses all formulas and defined names
+    /// Reparses all formulas and defined names
     pub(crate) fn reset_parsed_structures(&mut self) {
         self.parser
             .set_worksheets(self.workbook.get_worksheet_names());
@@ -153,7 +173,8 @@ impl Model {
         let sheet_name = format!("{}{}", base_name, index);
         // Now we need a sheet_id
         let sheet_id = self.get_new_sheet_id();
-        let worksheet = Model::new_empty_worksheet(&sheet_name, sheet_id);
+        let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
+        let worksheet = Model::new_empty_worksheet(&sheet_name, sheet_id, &view_ids);
         self.workbook.worksheets.push(worksheet);
         self.reset_parsed_structures();
         (sheet_name, self.workbook.worksheets.len() as u32 - 1)
@@ -184,7 +205,8 @@ impl Model {
             Some(id) => id,
             None => self.get_new_sheet_id(),
         };
-        let worksheet = Model::new_empty_worksheet(sheet_name, sheet_id);
+        let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
+        let worksheet = Model::new_empty_worksheet(sheet_name, sheet_id, &view_ids);
         if sheet_index as usize > self.workbook.worksheets.len() {
             return Err("Sheet index out of range".to_string());
         }
@@ -331,11 +353,21 @@ impl Model {
         // "2020-08-06T21:20:53Z
         let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
 
+        let mut views = HashMap::new();
+        views.insert(
+            0,
+            WorkbookView {
+                sheet: 0,
+                window_width: DEFAULT_WINDOW_WIDTH,
+                window_height: DEFAULT_WINDOW_HEIGH,
+            },
+        );
+
         // String versions of the locale are added here to simplify the serialize/deserialize logic
         let workbook = Workbook {
             shared_strings: vec![],
             defined_names: vec![],
-            worksheets: vec![Model::new_empty_worksheet("Sheet1", 1)],
+            worksheets: vec![Model::new_empty_worksheet("Sheet1", 1, &[&0])],
             styles: Default::default(),
             name: name.to_string(),
             settings: WorkbookSettings {
@@ -351,6 +383,7 @@ impl Model {
                 last_modified: now,
             },
             tables: HashMap::new(),
+            views,
         };
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
@@ -359,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 {
@@ -371,6 +405,7 @@ impl Model {
             locale,
             language,
             tz,
+            view_id: 0,
         };
         model.parse_formulas();
         Ok(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)?;
-        Ok(())
+        self.add_named_cell_style(style_name, style_index)
     }
 
-    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
+        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 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_with_format(
+        &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 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
+        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 {
-        let cell_xf = &self.cell_xfs[index as usize];
-
+    pub(crate) fn get_style(&self, index: i32) -> Result<Style, String> {
+        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,
-        }
+        })
     }
 }
 
@@ -218,11 +223,18 @@ impl Model {
         column: i32,
         style: &Style,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         let style_index = self.workbook.styles.get_style_index_or_create(style);
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
-        Ok(())
+            .set_cell_style(row, column, style_index)
     }
 
     pub fn copy_cell_style(
@@ -237,9 +249,7 @@ impl Model {
 
         self.workbook
             .worksheet_mut(destination_cell.0)?
-            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index);
-
-        Ok(())
+            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index)
     }
 
     /// Sets the style "style_name" in cell
@@ -250,11 +260,18 @@ impl Model {
         column: i32,
         style_name: &str,
     ) -> Result<(), String> {
+        // Checking first whether cell we are updating is part of Merged cells
+        // if so returning with Err
+        if self.is_part_of_merged_cells(sheet, row, column)? {
+            return Err(format!(
+                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
+                row, column
+            ));
+        }
         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);
-        Ok(())
+            .set_cell_style(row, column, style_index)
     }
 
     pub fn set_sheet_style(&mut self, sheet: u32, style_name: &str) -> Result<(), String> {

base/src/test/engineering/test_complex.rs

@@ -76,10 +76,16 @@ fn fn_imconjugate() {
 fn fn_imcos() {
     let mut model = new_empty_model();
     model._set("A1", r#"=IMCOS("4+3i")"#);
+    // In macos non intel this is "-6.58066304055116+7.58155274274655i"
+    model._set("A2", r#"=COMPLEX(-6.58066304055116, 7.58155274274654)"#);
+    model._set("A3", r#"=IMABS(IMSUB(A1, A2)) < G1"#);
+
+    // small number
+    model._set("G1", "0.0000001");
 
     model.evaluate();
 
-    assert_eq!(model._get_text("A1"), "-6.58066304055116+7.58155274274654i");
+    assert_eq!(model._get_text("A3"), "TRUE");
 }
 
 #[test]

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;
@@ -51,6 +53,9 @@ mod test_extend;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_get_cell_content;
+mod test_model_merge_cell_fns;
 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,5 @@ 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));
 }

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,47 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_cases() {}
+
+#[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_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

@@ -17,7 +17,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 +45,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 +56,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, 2, "= A1* 2-4".to_string()); // B1
+    model.set_user_input(0, 1, 1, "23".to_string()).unwrap(); // A1
+    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 +69,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 +80,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.set_user_input(0, 1, 2, "=A1".to_string());
+    model
+        .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");
@@ -152,21 +160,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, 2, 1, "TRUE".to_string());
-    model.set_user_input(0, 3, 1, "True".to_string());
-    model.set_user_input(0, 4, 1, "false".to_string());
-    model.set_user_input(0, 5, 1, "FALSE".to_string());
-    model.set_user_input(0, 6, 1, "False".to_string());
+    model.set_user_input(0, 1, 1, "true".to_string()).unwrap();
+    model.set_user_input(0, 2, 1, "TRUE".to_string()).unwrap();
+    model.set_user_input(0, 3, 1, "True".to_string()).unwrap();
+    model.set_user_input(0, 4, 1, "false".to_string()).unwrap();
+    model.set_user_input(0, 5, 1, "FALSE".to_string()).unwrap();
+    model.set_user_input(0, 6, 1, "False".to_string()).unwrap();
 
-    model.set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string());
-    model.set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string());
-    model.set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string());
-    model.set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string());
-    model.set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string());
-    model.set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=ISLOGICAL(A2)".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 +213,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 +233,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 +256,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 style_index = model.get_cell_style_index(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).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 +272,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, 2, 1, "2".to_string()); // A2
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
+    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, 2, 1, 2.0);
+    model.update_cell_with_number(0, 1, 2, 1.0).unwrap();
+    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 +302,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 +379,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 +431,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_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.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+    model
+        .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_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_model_merge_cell_fns.rs

@@ -0,0 +1,155 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{test::util::new_empty_model, types::CellType};
+
+#[test]
+fn test_model_set_fns_related_to_merge_cells() {
+    let mut model = new_empty_model();
+
+    // creating a merge cell of D1:F2
+    model.merge_cells(0, "D1:F2").unwrap();
+
+    // Updating the mother cell of Merge cells and expecting the update to go through
+    model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
+    assert_eq!(model.get_cell_content(0, 1, 4).unwrap(), "Hello");
+    assert_eq!(model.get_cell_type(0, 1, 4).unwrap(), CellType::Text);
+
+    // Updating cell which is not in Merge cell block
+    assert_eq!(model.set_user_input(0, 1, 3, "Hello".to_string()), Ok(()));
+    assert_eq!(model.get_cell_content(0, 1, 3), Ok("Hello".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 3), Ok(CellType::Text));
+
+    // 1: testing with set_user_input()
+    assert_eq!(
+        model
+            .set_user_input(0, 1, 5, "Hello".to_string()),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 2: testing with update_cell_with_bool()
+    assert_eq!(
+        model
+            .update_cell_with_bool(0, 1, 5, true),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 3: testing with update_cell_with_formula()
+    assert_eq!(
+        model
+            .update_cell_with_formula(0, 1, 5, "=SUM(A1+A2)".to_string()),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 4: testing with update_cell_with_number()
+    assert_eq!(
+        model
+            .update_cell_with_number(0, 1, 5, 10.0),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+
+    // 5: testing with update_cell_with_text()
+    assert_eq!(
+        model
+            .update_cell_with_text(0, 1, 5, "new text"),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
+    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
+}
+
+#[test]
+fn test_model_merge_cells_crud_api() {
+    let mut model = new_empty_model();
+
+    // creating a merge cell of D4:F6
+    model.merge_cells(0, "D4:F6").unwrap();
+    model
+        .set_user_input(0, 4, 4, "Merge Block".to_string())
+        .unwrap();
+    // CRUD APIS testing on Merge Cells
+
+    // Case1: Creating a new merge cell without overlapping
+    // Newly created Merge block is left to D4:F6
+    assert_eq!(model.merge_cells(0, "A1:B4"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        2
+    );
+    model.set_user_input(0, 1, 1, "left".to_string()).unwrap();
+
+    // Newly created Merge block is right to D4:F6
+    assert_eq!(model.merge_cells(0, "G1:H7"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        3
+    );
+    model.set_user_input(0, 1, 7, "right".to_string()).unwrap();
+
+    // Newly created Merge block is above to D4:F6
+    assert_eq!(model.merge_cells(0, "C1:D3"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        4
+    );
+    model.set_user_input(0, 1, 3, "top".to_string()).unwrap();
+
+    // Newly created Merge block is down to D4:F6
+    assert_eq!(model.merge_cells(0, "D8:E9"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        5
+    );
+    model.set_user_input(0, 8, 4, "down".to_string()).unwrap();
+
+    // Case2: Creating a new merge cell with overlapping with other 3 merged cell
+    assert_eq!(model.merge_cells(0, "C1:G4"), Ok(()));
+    assert_eq!(
+        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
+        3
+    );
+    model
+        .set_user_input(0, 1, 3, "overlapped_new_merge_block".to_string())
+        .unwrap();
+
+    // Case3: Giving wrong parsing range
+    assert_eq!(
+        model.merge_cells(0, "C3:A1"),
+        Err("Invalid parse range. Merge Mother cell always be top left cell".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "CA:A1"),
+        Err("Invalid range: 'CA:A1'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C0:A1"),
+        Err("Invalid range: 'C0:A1'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C1:A0"),
+        Err("Invalid range: 'C1:A0'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C1"),
+        Err("Invalid range: 'C1'".to_string())
+    );
+    assert_eq!(
+        model.merge_cells(0, "C1:A1:B1"),
+        Err("Invalid range: 'C1:A1:B1'".to_string())
+    );
+
+    // Case3: Giving wrong merge_ref, which would resulting in error (Merge cell to be deleted is not found)
+    assert_eq!(
+        model.unmerge_cells(0, "C1:E1"),
+        Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
+    );
+
+    // Case4: unmerge scenario
+    assert_eq!(model.unmerge_cells(0, "C1:G4"), Ok(()));
+}

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.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+    model
+        .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.set_user_input(0, 2, 2, "=ISNUMBER(A2)".to_string());
+    model
+        .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, 2, "=ISNUMBER(A3)".to_string());
+    model.set_user_input(0, 3, 1, "100$".to_string()).unwrap();
+    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, 2, 1, "5e-4$".to_string());
-    model.set_user_input(0, 3, 1, "6e-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()).unwrap();
+    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, 2, "=ISNUMBER(A10)".to_string());
-    model.set_user_input(0, 11, 1, "55.759%".to_string());
+    model.set_user_input(0, 10, 1, "50%".to_string()).unwrap();
+    model
+        .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, 4, 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()).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.set_user_input(0, 21, 1, "50,12.549".to_string());
-    model.set_user_input(0, 22, 1, "1,234567".to_string());
+    model
+        .set_user_input(0, 20, 1, "50,123.549".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, 2, 1, "-$99.123".to_string());
+    model.set_user_input(0, 1, 1, "-$100".to_string()).unwrap();
+    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, 2, 2, "-92.689$".to_string());
+    model.set_user_input(0, 1, 2, "-200$".to_string()).unwrap();
+    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, 4, 1, "=SUM(A1:A3)".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())
+        .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, 2, 2, "=A1*A3".to_string());
-    model.set_user_input(0, 3, 2, "=A1*3".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()).unwrap();
+    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, 2, 2, "=A1/A3".to_string());
-    model.set_user_input(0, 3, 2, "=A1/2".to_string());
-    model.set_user_input(0, 4, 2, "=100/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()).unwrap();
+    model.set_user_input(0, 3, 2, "=A1/2".to_string()).unwrap();
+    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, 4, 3, "=C2*C1".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()).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, 4, 4, "=D2*D1".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()).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, 4, 5, "=E2+E1".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()).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, 4, 6, "=F2*F1".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()).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, 4, 7, "=G2*G1".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()).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, 4, 8, "=H2*H1".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()).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, 4, 9, "=I2*I1".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()).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.set_user_input(0, 6, 1, "=PMT(A2/12,A3,A4,,1)".to_string());
-    model.set_user_input(0, 7, 1, "=PMT(0.2, 3, -200)".to_string());
+    model
+        .set_user_input(0, 5, 1, "=PMT(A2/12,A3,A4)".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.set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string());
-    model.set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=SUM(A:A)".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.set_user_input(0, 2, 1, "25€".to_string());
+    model
+        .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.set_user_input(0, 2, 2, "-42€".to_string());
+    model
+        .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.set_user_input(0, 2, 3, "26 €".to_string());
+    model
+        .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.set_user_input(0, 2, 4, "-45 €".to_string());
+    model
+        .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.set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string());
-    model.set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=SUM(A:A)".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, 2, 1, "42".to_string()); // A2
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
+    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,48 @@ 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);
 }
+
+#[test]
+fn test_model_style_set_fns_in_merge_cell_context() {
+    let mut model = new_empty_model();
+
+    // creating a merge cell of D1:F2
+    model.merge_cells(0, "D1:F2").unwrap();
+    model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
+
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
+    assert!(!style.font.b);
+    style.font.b = true;
+
+    // Updating the mother cell of Merge cells and expecting the update to go through
+    // This should make the text "Hello" in bold format
+    assert_eq!(model.set_cell_style(0, 1, 4, &style), Ok(()));
+
+    // 1: testing with set_cell_style()
+    let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
+    assert_eq!(
+        model
+            .set_cell_style(0, 1, 5, &style),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
+
+    // 2: testing with set_cell_style_by_name
+    let mut style = model.get_style_for_cell(0, 1, 4).unwrap();
+    style.font.b = true;
+    assert_eq!(
+        model.workbook.styles.create_named_style("bold", &style),
+        Ok(())
+    );
+
+    let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
+    assert_eq!(
+        model
+            .set_cell_style_by_name(0, 1, 5, "bold"),
+        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
+    );
+    assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
+}

base/src/test/test_types.rs

@@ -0,0 +1,24 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::types::{Alignment, HorizontalAlignment, VerticalAlignment};
+
+#[test]
+fn alignment_default() {
+    let alignment = Alignment::default();
+    assert_eq!(
+        alignment,
+        Alignment {
+            horizontal: HorizontalAlignment::General,
+            vertical: VerticalAlignment::Bottom,
+            wrap_text: false
+        }
+    );
+
+    let s = serde_json::to_string(&alignment).unwrap();
+    // defaults stringifies as an empty object
+    assert_eq!(s, "{}");
+
+    let a: Alignment = serde_json::from_str("{}").unwrap();
+
+    assert_eq!(a, alignment)
+}

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();
             }
         }
     }
@@ -273,3 +283,87 @@ fn test_worksheet_navigate_to_edge_in_direction() {
     assert_eq!(navigate(8, 3, NavigationDirection::Up), (6, 3));
     assert_eq!(navigate(9, 3, NavigationDirection::Up), (6, 3));
 }
+
+// Tests Merge cells related functions of worksheet
+
+#[test]
+fn test_merge_cell_fns_worksheet() {
+    let mut model = new_empty_model();
+
+    // Adding one Merge cell
+    model.merge_cells(0, "D1:E3").unwrap();
+
+    // Lets check whether D1 (Mother Merge cell) is part of Merge block or not
+    // It should not be considered as part of Merge cell
+    assert!(!model
+        .workbook
+        .worksheet(0)
+        .unwrap()
+        .is_part_of_merged_cells(1, 4)
+        .unwrap(),);
+
+    // Lets give cell which is actually part of Merge block and expect true from fn
+    assert!(model
+        .workbook
+        .worksheet(0)
+        .unwrap()
+        .is_part_of_merged_cells(2, 4)
+        .unwrap());
+
+    // Lets give cell which is not a part of Merge block and expect false from fn
+    assert!(!model
+        .workbook
+        .worksheet(0)
+        .unwrap()
+        .is_part_of_merged_cells(2, 6)
+        .unwrap());
+
+    // Lets give an Invalid row
+    assert_eq!(
+        model
+            .workbook
+            .worksheet(0)
+            .unwrap()
+            .is_part_of_merged_cells(0, 1),
+        Err("Incorrect row or column".to_string())
+    );
+
+    //Lets give Invalid column
+    assert_eq!(
+        model
+            .workbook
+            .worksheet(0)
+            .unwrap()
+            .is_part_of_merged_cells(1, 0),
+        Err("Incorrect row or column".to_string())
+    );
+
+    // Verifying get fns of worksheet
+    assert_eq!(
+        model
+            .workbook
+            .worksheet(0)
+            .unwrap()
+            .get_merged_cells_list()
+            .len(),
+        1
+    );
+    {
+        let merge_cell_vec = model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .get_merged_cells_list_mut();
+        merge_cell_vec.remove(0);
+
+        assert_eq!(
+            model
+                .workbook
+                .worksheet(0)
+                .unwrap()
+                .get_merged_cells_list()
+                .len(),
+            0
+        );
+    }
+}

base/src/test/user_model/mod.rs

@@ -1,10 +1,22 @@
 mod test_add_delete_sheets;
+mod test_autofill_columns;
+mod test_autofill_rows;
+mod test_border;
 mod test_clear_cells;
 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_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_HEIGH, 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_HEIGH 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,187 @@
+#![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((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 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((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,
 };
 
@@ -144,13 +144,20 @@ 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
         .update_range_style(&range, "fill.bg_color", "#F2F2F2")
         .unwrap();
+    model
+        .update_range_style(&range, "fill.fg_color", "#F3F4F5")
+        .unwrap();
     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();
 
@@ -159,6 +166,7 @@ fn basic_fill() {
 
     let style = model2.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()));
 }
 
 #[test]
@@ -171,9 +179,15 @@ fn fill_errors() {
         width: 1,
         height: 1,
     };
-    assert!(model
-        .update_range_style(&range, "fill.bg_color", "#FFF")
-        .is_err());
+    assert_eq!(
+        model.update_range_style(&range, "fill.bg_color", "#FFF"),
+        Err("Invalid color: '#FFF'.".to_string())
+    );
+
+    assert_eq!(
+        model.update_range_style(&range, "fill.fg_color", "#FFF"),
+        Err("Invalid color: '#FFF'.".to_string())
+    );
 }
 
 #[test]
@@ -215,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();
@@ -553,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

@@ -0,0 +1,209 @@
+#![allow(clippy::unwrap_used)]
+
+use std::collections::HashMap;
+
+use crate::{
+    constants::{LAST_COLUMN, LAST_ROW},
+    test::util::new_empty_model,
+    user_model::SelectedView,
+    UserModel,
+};
+
+#[test]
+fn initial_view() {
+    let model = new_empty_model();
+    let model = UserModel::from_model(model);
+    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 1,
+            left_column: 1
+        }
+    );
+}
+
+#[test]
+fn set_the_cell_sets_the_range() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(5, 4).unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_cell(), (0, 5, 4));
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 5,
+            column: 4,
+            range: [5, 4, 5, 4],
+            top_row: 1,
+            left_column: 1
+        }
+    );
+}
+
+#[test]
+fn set_the_range_does_not_set_the_cell() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    assert_eq!(
+        model.set_selected_range(5, 4, 10, 6),
+        Err(
+            "The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
+                .to_string()
+        )
+    );
+}
+
+#[test]
+fn add_new_sheet_and_back() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.new_sheet().unwrap();
+    assert_eq!(model.get_selected_sheet(), 1);
+    model.set_selected_cell(5, 4).unwrap();
+    model.set_selected_sheet(0).unwrap();
+    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]
+fn set_selected_cell_errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    assert_eq!(
+        model.set_selected_cell(-5, 4),
+        Err("Invalid row: '-5'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_cell(5, -4),
+        Err("Invalid column: '-4'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(-1, 1, 1, 1),
+        Err("Invalid row: '-1'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(1, 0, 1, 1),
+        Err("Invalid column: '0'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(1, 1, LAST_ROW + 1, 1),
+        Err("Invalid row: '1048577'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(1, 1, 1, LAST_COLUMN + 1),
+        Err("Invalid column: '16385'".to_string())
+    );
+}
+
+#[test]
+fn set_selected_cell_errors_wrong_sheet() {
+    let mut model = new_empty_model();
+    // forcefully set a wrong index
+    model.workbook.views.get_mut(&0).unwrap().sheet = 2;
+    let mut model = UserModel::from_model(model);
+    // It's returning the wrong number
+    assert_eq!(model.get_selected_sheet(), 2);
+
+    // But we can't set the selected cell anymore
+    assert_eq!(
+        model.set_selected_cell(3, 4),
+        Err("Invalid worksheet index 2".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(3, 4, 5, 6),
+        Err("Invalid worksheet index 2".to_string())
+    );
+
+    assert_eq!(
+        model.set_top_left_visible_cell(3, 4),
+        Err("Invalid worksheet index 2".to_string())
+    );
+
+    // we can fix it by setting the right cell
+    model.set_selected_sheet(0).unwrap();
+    model.set_selected_cell(3, 4).unwrap();
+}
+
+#[test]
+fn set_visible_cell() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_top_left_visible_cell(100, 12).unwrap();
+
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 100,
+            left_column: 12
+        }
+    );
+
+    let s = serde_json::to_string(&model.get_selected_view()).unwrap();
+    assert_eq!(
+        serde_json::from_str::<SelectedView>(&s).unwrap(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 100,
+            left_column: 12
+        }
+    );
+}
+
+#[test]
+fn set_visible_cell_errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    assert_eq!(
+        model.set_top_left_visible_cell(-100, 12),
+        Err("Invalid row: '-100'".to_string())
+    );
+    assert_eq!(
+        model.set_top_left_visible_cell(100, -12),
+        Err("Invalid column: '-12'".to_string())
+    );
+}
+
+#[test]
+fn errors_no_views() {
+    let mut model = new_empty_model();
+    // forcefully remove the view
+    model.workbook.views = HashMap::new();
+    // also in the sheet
+    model.workbook.worksheets[0].views = HashMap::new();
+    let mut model = UserModel::from_model(model);
+    // get methods will return defaults
+    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 1,
+            left_column: 1
+        }
+    );
+
+    // set methods won't complain. but won't work either
+    model.set_selected_sheet(0).unwrap();
+    model.set_selected_cell(5, 6).unwrap();
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+}

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_HEIGH, 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_HEIGH);
+
+    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

@@ -3,38 +3,17 @@ use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt::Display};
 
 use crate::expressions::token::Error;
-
-// Useful for `#[serde(default = "default_as_true")]`
-fn default_as_true() -> bool {
-    true
-}
+use crate::expressions::utils::number_to_column;
 
 fn default_as_false() -> bool {
     false
 }
 
-// Useful for `#[serde(skip_serializing_if = "is_true")]`
-fn is_true(b: &bool) -> bool {
-    *b
-}
-
 fn is_false(b: &bool) -> bool {
     !*b
 }
 
-fn is_zero(num: &i32) -> bool {
-    *num == 0
-}
-
-fn is_default_alignment(o: &Option<Alignment>) -> bool {
-    o.is_none() || *o == Some(Alignment::default())
-}
-
-fn hashmap_is_empty(h: &HashMap<String, Table>) -> bool {
-    h.values().len() == 0
-}
-
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Metadata {
     pub application: String,
     pub app_version: String,
@@ -44,14 +23,25 @@ pub struct Metadata {
     pub last_modified: String, //"2020-11-20T16:24:35"
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct WorkbookSettings {
     pub tz: String,
     pub locale: String,
 }
+
+/// A Workbook View tracks of the selected sheet for each view
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+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 heigh of the window
+    pub window_height: i64,
+}
+
 /// An internal representation of an IronCalc Workbook
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Workbook {
     pub shared_strings: Vec<String>,
     pub defined_names: Vec<DefinedName>,
@@ -60,28 +50,22 @@ pub struct Workbook {
     pub name: String,
     pub settings: WorkbookSettings,
     pub metadata: Metadata,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "hashmap_is_empty")]
     pub tables: HashMap<String, Table>,
+    pub views: HashMap<u32, WorkbookView>,
 }
 
 /// A defined name. The `sheet_id` is the sheet index in case the name is local
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct DefinedName {
     pub name: String,
     pub formula: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub sheet_id: Option<u32>,
 }
 
-// TODO: Move to worksheet.rs make frozen_rows/columns private and u32
-/// Internal representation of a worksheet Excel object
-
 /// * state:
 ///    18.18.68 ST_SheetState (Sheet Visibility Types)
 ///    hidden, veryHidden, visible
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
-#[serde(rename_all = "lowercase")]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum SheetState {
     Visible,
     Hidden,
@@ -98,8 +82,25 @@ impl Display for SheetState {
     }
 }
 
+/// Represents the state of the worksheet as seen by the user. This includes
+/// details such as the currently selected cell, the visible range, and the
+/// position of the viewport.
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+pub struct WorksheetView {
+    /// The row index of the currently selected cell.
+    pub row: i32,
+    /// The column index of the currently selected cell.
+    pub column: i32,
+    /// The selected range in the worksheet, specified as [start_row, start_column, end_row, end_column].
+    pub range: [i32; 4],
+    /// The row index of the topmost visible cell in the worksheet view.
+    pub top_row: i32,
+    /// The column index of the leftmost visible cell in the worksheet view.
+    pub left_column: i32,
+}
+
 /// Internal representation of a worksheet Excel object
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Worksheet {
     pub dimension: String,
     pub cols: Vec<Col>,
@@ -109,16 +110,14 @@ pub struct Worksheet {
     pub shared_formulas: Vec<String>,
     pub sheet_id: u32,
     pub state: SheetState,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub color: Option<String>,
-    pub merge_cells: Vec<String>,
+    pub merged_cells_list: Vec<MergedCells>,
     pub comments: Vec<Comment>,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "is_zero")]
     pub frozen_rows: i32,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "is_zero")]
     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
@@ -126,7 +125,7 @@ pub struct Worksheet {
 pub type SheetData = HashMap<i32, HashMap<i32, Cell>>;
 
 // ECMA-376-1:2016 section 18.3.1.73
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Row {
     /// Row index
     pub r: i32,
@@ -134,23 +133,19 @@ pub struct Row {
     pub custom_format: bool,
     pub custom_height: bool,
     pub s: i32,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub hidden: bool,
 }
 
 // ECMA-376-1:2016 section 18.3.1.13
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Col {
     // Column definitions are defined on ranges, unlike rows which store unique, per-row entries.
     /// First column affected by this record. Settings apply to column in \[min, max\] range.
     pub min: i32,
     /// Last column affected by this record. Settings apply to column in \[min, max\] range.
     pub max: i32,
-
     pub width: f64,
     pub custom_width: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub style: Option<i32>,
 }
 
@@ -165,32 +160,55 @@ pub enum CellType {
     CompoundData = 128,
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq)]
-#[serde(tag = "t", deny_unknown_fields)]
+#[derive(Encode, Decode, Debug, Clone, PartialEq)]
 pub enum Cell {
-    #[serde(rename = "empty")]
-    EmptyCell { s: i32 },
-    #[serde(rename = "b")]
-    BooleanCell { v: bool, s: i32 },
-    #[serde(rename = "n")]
-    NumberCell { v: f64, s: i32 },
+    EmptyCell {
+        s: i32,
+    },
+
+    BooleanCell {
+        v: bool,
+        s: i32,
+    },
+
+    NumberCell {
+        v: f64,
+        s: i32,
+    },
     // Maybe we should not have this type. In Excel this is just a string
-    #[serde(rename = "e")]
-    ErrorCell { ei: Error, s: i32 },
+    ErrorCell {
+        ei: Error,
+        s: i32,
+    },
     // Always a shared string
-    #[serde(rename = "s")]
-    SharedString { si: i32, s: i32 },
+    SharedString {
+        si: i32,
+        s: i32,
+    },
     // Non evaluated Formula
-    #[serde(rename = "u")]
-    CellFormula { f: i32, s: i32 },
-    #[serde(rename = "fb")]
-    CellFormulaBoolean { f: i32, v: bool, s: i32 },
-    #[serde(rename = "fn")]
-    CellFormulaNumber { f: i32, v: f64, s: i32 },
+    CellFormula {
+        f: i32,
+        s: i32,
+    },
+
+    CellFormulaBoolean {
+        f: i32,
+        v: bool,
+        s: i32,
+    },
+
+    CellFormulaNumber {
+        f: i32,
+        v: f64,
+        s: i32,
+    },
     // always inline string
-    #[serde(rename = "str")]
-    CellFormulaString { f: i32, v: String, s: i32 },
-    #[serde(rename = "fe")]
+    CellFormulaString {
+        f: i32,
+        v: String,
+        s: i32,
+    },
+
     CellFormulaError {
         f: i32,
         ei: Error,
@@ -209,17 +227,16 @@ impl Default for Cell {
     }
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Comment {
     pub text: String,
     pub author_name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub author_id: Option<String>,
     pub cell_ref: String,
 }
 
 // ECMA-376-1:2016 section 18.5.1.2
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Table {
     pub name: String,
     pub display_name: String,
@@ -227,34 +244,24 @@ pub struct Table {
     pub reference: String,
     pub totals_row_count: u32,
     pub header_row_count: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub header_row_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub data_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub totals_row_dxf_id: Option<u32>,
     pub columns: Vec<TableColumn>,
     pub style_info: TableStyleInfo,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub has_filters: bool,
 }
 
 // totals_row_label vs totals_row_function might be mutually exclusive. Use an enum?
 // the totals_row_function is an enum not String methinks
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct TableColumn {
     pub id: u32,
     pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub totals_row_label: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub header_row_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub data_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub totals_row_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub totals_row_function: Option<String>,
 }
 
@@ -272,25 +279,16 @@ impl Default for TableColumn {
     }
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
 pub struct TableStyleInfo {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub show_first_column: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub show_last_column: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub show_row_stripes: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub show_column_stripes: bool,
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Styles {
     pub num_fmts: Vec<NumFmt>,
     pub fonts: Vec<Font>,
@@ -326,7 +324,7 @@ pub struct Style {
     pub quote_prefix: bool,
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct NumFmt {
     pub num_fmt_id: i32,
     pub format_code: String,
@@ -354,6 +352,43 @@ pub enum FontScheme {
     None,
 }
 
+// MergedCells type
+// There will be one MergedCells struct maintained for every Merged cells that we load
+// merge_cell_range : Its tuple having [row_start, column_start, row_end, column_end]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+pub struct MergedCells(pub i32, pub i32, pub i32, pub i32);
+
+// implementing accessor function
+impl MergedCells {
+    // Method which returns range_ref from the tuple
+    // ex : (3,1,4,2) is interpreted as A3:B4
+    pub fn get_merged_cells_str_ref(&self) -> Result<String, String> {
+        let start_column = number_to_column(self.1).ok_or(format!(
+            "Error while converting column start {} number to column string ref",
+            self.1
+        ))?;
+        let end_column = number_to_column(self.3).ok_or(format!(
+            "Error while converting column end {} number to column string ref",
+            self.3
+        ))?;
+        return Ok(start_column
+            + &self.0.to_string()
+            + &":".to_string()
+            + &end_column
+            + &self.2.to_string());
+    }
+
+    // Only Public function where Merge cell can be created
+    pub fn new(merge_cell_parsed_range: (i32, i32, i32, i32)) -> Self {
+        Self(
+            merge_cell_parsed_range.0,
+            merge_cell_parsed_range.1,
+            merge_cell_parsed_range.2,
+            merge_cell_parsed_range.3,
+        )
+    }
+}
+
 impl Display for FontScheme {
     fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
@@ -516,29 +551,17 @@ pub struct Alignment {
     pub wrap_text: bool,
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct CellStyleXfs {
     pub num_fmt_id: i32,
     pub font_id: i32,
     pub fill_id: i32,
     pub border_id: i32,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
     pub apply_number_format: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
     pub apply_border: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
     pub apply_alignment: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
     pub apply_protection: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
     pub apply_font: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
     pub apply_fill: bool,
 }
 
@@ -559,39 +582,24 @@ impl Default for CellStyleXfs {
     }
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
 pub struct CellXfs {
     pub xf_id: i32,
     pub num_fmt_id: i32,
     pub font_id: i32,
     pub fill_id: i32,
     pub border_id: i32,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub apply_number_format: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub apply_border: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub apply_alignment: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub apply_protection: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub apply_font: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub apply_fill: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
     pub quote_prefix: bool,
-    #[serde(skip_serializing_if = "is_default_alignment")]
     pub alignment: Option<Alignment>,
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct CellStyles {
     pub name: String,
     pub xf_id: i32,
@@ -608,7 +616,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(