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/rust-build-test.yaml

@@ -16,6 +16,9 @@ jobs:
         steps:
             - uses: actions/checkout@v3
 
+            - name: Install wasm-pack
+              run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
             - name: Build
               run: cargo build --release --verbose
 

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

@@ -4,6 +4,8 @@ resolver = "2"
 members = [
   "base",
   "xlsx",
+  "bindings/wasm",
+  "bindings/python",
 ]
 
 exclude = [

Makefile

@@ -1,33 +1,44 @@
+.PHONY: lint
 lint:
 	cargo fmt -- --check
-	cargo clippy --all-targets --all-features
+	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
+	cd webapp && npm install && npm run check
 
+.PHONY: format
 format:
 	cargo fmt
 
+.PHONY: tests
 tests: lint
-	cargo test
-	make remove-xlsx
+	make remove-artifacts
+	# 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
 
-remove-xlsx:
+.PHONY: remove-artifacts
+remove-artifacts:
 	rm -f xlsx/hello-calc.xlsx
 	rm -f xlsx/hello-styles.xlsx
 	rm -f xlsx/widths-and-heights.xlsx
 
-clean: remove-xlsx
+.PHONY: clean
+clean: remove-artifacts
 	cargo clean
 	rm -r -f base/target
 	rm -r -f xlsx/target
+	rm -r -f bindings/python/target
+	rm -r -f bindings/wasm/targets
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*
 
-
+.PHONY: coverage
 coverage:
 	CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
 	grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
 
+.PHONY: docs
 docs:
 	cargo doc --no-deps
-
-.PHONY: lint format tests docs coverage all

README.md

@@ -117,66 +117,18 @@ See more examples in the `examples` folder of the xlsx crate.
 
 # ROADMAP
 
-> [!WARNING]  
-> This is work-in-progress. IronCalc in developed in the open. Expect things to be broken and change quickly until version 0.5
-
-Major milestones:
-
-* MVP, version 0.5.0: We intend to have a working version by mid March 2024 (version 0.5, MVP)
-* Stable, version 1.0.0 will come later in December 2024
-
-MVP stands for _Minimum Viable Product_
-
-## Version 0.5 or MVP (early 2024)
-
-Version 0.5 includes the engine, javascript and nodejs bindings and a web application
-
-Features of the engine include:
-
-* Read and write xlsx files
-* API to set and read values from cells
-* Implemented 192 Excel functions
-* Time functions with timezones
-* Prepared for i18n but will only support English
-* Wide test coverage
-
-UI features of the web application (backed by the engine):
-
-* Enter values and formulas. Browse mode
-* Italics, bold, underline, horizontal alignment
-* Number formatting
-* Add/remove/rename sheets
-* Copy/Paste extend values
-* Keyboard navigation
-* Delete/Add rows and columns
-* Resize rows and columns
-* Correct scrolling and navigation
-
-## Version 1.0 or Stable (December 2024)
-
-Minor milestones in the ROADMAD for version 1.0.0 (engine and UI):
-
-* Implementation of arrays and array formulas
-* Formula documentation and context help
-* Merge cells
-* Pivot tables
-* Define name manager (mostly UI)
-* Update main evaluation algorithm with a support graph
-* Dynamic arrays (SORT, UNIQUE, ..)
-* Full i18n support with different locales and languages
-* Python bindings
-* Full test coverage
+See https://github.com/ironcalc
 
 # Early testing
 
 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.2"
+version = "0.2.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
@@ -12,18 +12,27 @@ 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.7.0"
-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.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.60" }
+js-sys = { version = "0.3.69" }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-rand = "0.8.4"
+rand = "0.8.5"
 
 

base/examples/formulas_and_errors.rs

@@ -1,17 +1,17 @@
-use ironcalc_base::{model::Model, types::CellType};
+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

@@ -1,13 +1,13 @@
-use ironcalc_base::{cell::CellValue, model::Model};
+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

@@ -77,14 +77,13 @@ impl Model {
         let style = source_cell.get_style();
         // FIXME: we need some user_input getter instead of get_text
         let formula_or_value = self
-            .cell_formula(sheet, source_row, source_column)?
+            .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.delete_cell(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.
@@ -157,6 +156,11 @@ impl Model {
             return Err("Please use insert columns instead".to_string());
         }
 
+        // first column being deleted
+        let column_start = column;
+        // last column being deleted
+        let column_end = column + column_count - 1;
+
         // Move cells
         let worksheet = &self.workbook.worksheet(sheet)?;
         let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -166,11 +170,11 @@ impl Model {
         for r in all_rows {
             let columns: Vec<i32> = self.get_columns_for_row(sheet, r, false)?;
             for col in columns {
-                if col >= column {
-                    if col >= column + column_count {
+                if col >= column_start {
+                    if col > column_end {
                         self.move_cell(sheet, r, col, r, col - column_count)?;
                     } else {
-                        self.delete_cell(sheet, r, col)?;
+                        self.cell_clear_all(sheet, r, col)?;
                     }
                 }
             }
@@ -184,6 +188,64 @@ impl Model {
                 delta: -column_count,
             }),
         );
+        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
+
+        // deletes all the column styles
+        let mut new_columns = Vec::new();
+        for col in worksheet.cols.iter_mut() {
+            // range under study
+            let min = col.min;
+            let max = col.max;
+            // In the diagram:
+            // |xxxxx| range we are studying [min, max]
+            // |*****| range we are deleting [column_start, column_end]
+            // we are going to split it in three big cases:
+            // ----------------|xxxxxxxx|-----------------
+            // -----|*****|------------------------------- Case A
+            // -------|**********|------------------------ Case B
+            // -------------|**************|-------------- Case C
+            // ------------------|****|------------------- Case D
+            // ---------------------|**********|---------- Case E
+            // -----------------------------|*****|------- Case F
+            if column_start < min {
+                if column_end < min {
+                    // Case A
+                    // We displace all columns
+                    let mut new_column = col.clone();
+                    new_column.min = min - column_count;
+                    new_column.max = max - column_count;
+                    new_columns.push(new_column);
+                } else if column_end < max {
+                    // Case B
+                    // We displace the end
+                    let mut new_column = col.clone();
+                    new_column.min = column_start;
+                    new_column.max = max - column_count;
+                    new_columns.push(new_column);
+                } else {
+                    // Case C
+                    // skip this, we are deleting the whole range
+                }
+            } else if column_start <= max {
+                if column_end <= max {
+                    // Case D
+                    // We displace the end
+                    let mut new_column = col.clone();
+                    new_column.max = max - column_count;
+                    new_columns.push(new_column);
+                } else {
+                    // Case E
+                    let mut new_column = col.clone();
+                    new_column.max = column_start - 1;
+                    new_columns.push(new_column);
+                }
+            } else {
+                // Case F
+                // No action required
+                new_columns.push(col.clone());
+            }
+        }
+        worksheet.cols = new_columns;
 
         Ok(())
     }
@@ -283,7 +345,7 @@ impl Model {
                     // remove all cells in row
                     // FIXME: We could just remove the entire row in one go
                     for column in columns {
-                        self.delete_cell(sheet, r, column)?;
+                        self.cell_clear_all(sheet, r, column)?;
                     }
                 }
             }

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/mod.rs

@@ -308,9 +308,9 @@ impl Lexer {
                                 return self.consume_range(None);
                             }
                             let name_upper = name.to_ascii_uppercase();
-                            if name_upper == self.language.booleans.true_value {
+                            if name_upper == self.language.booleans.r#true {
                                 return TokenType::Boolean(true);
-                            } else if name_upper == self.language.booleans.false_value {
+                            } else if name_upper == self.language.booleans.r#false {
                                 return TokenType::Boolean(false);
                             }
                             if self.mode == LexerMode::A1 {
@@ -660,8 +660,8 @@ impl Lexer {
     fn consume_error(&mut self) -> TokenType {
         let errors = &self.language.errors;
         let rest_of_formula: String = self.chars[self.position - 1..self.len].iter().collect();
-        if rest_of_formula.starts_with(&errors.ref_value) {
-            self.position += errors.ref_value.chars().count() - 1;
+        if rest_of_formula.starts_with(&errors.r#ref) {
+            self.position += errors.r#ref.chars().count() - 1;
             return TokenType::Error(Error::REF);
         } else if rest_of_formula.starts_with(&errors.name) {
             self.position += errors.name.chars().count() - 1;

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

@@ -6,11 +6,11 @@ use crate::{
         token::TokenType,
     },
     language::get_language,
-    locale::get_locale_fix,
+    locale::get_locale,
 };
 
 fn new_language_lexer(formula: &str, locale: &str, language: &str) -> Lexer {
-    let locale = get_locale_fix(locale).unwrap();
+    let locale = get_locale(locale).unwrap();
     let language = get_language(language).unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)
 }

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

@@ -1,7 +1,7 @@
 use std::fmt;
 
+use bitcode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
-use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::language::Language;
 
@@ -80,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, Debug, PartialEq, Eq, Clone)]
-#[repr(u8)]
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Error {
     REF,
     NAME,
@@ -119,7 +118,7 @@ impl Error {
     pub fn to_localized_error_string(&self, language: &Language) -> String {
         match self {
             Error::NULL => language.errors.null.to_string(),
-            Error::REF => language.errors.ref_value.to_string(),
+            Error::REF => language.errors.r#ref.to_string(),
             Error::NAME => language.errors.name.to_string(),
             Error::VALUE => language.errors.value.to_string(),
             Error::DIV => language.errors.div.to_string(),
@@ -136,7 +135,7 @@ impl Error {
 
 pub fn get_error_by_name(name: &str, language: &Language) -> Option<Error> {
     let errors = &language.errors;
-    if name == errors.ref_value {
+    if name == errors.r#ref {
         return Some(Error::REF);
     } else if name == errors.name {
         return Some(Error::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/date_and_time.rs

@@ -1,7 +1,6 @@
+use chrono::DateTime;
 use chrono::Datelike;
 use chrono::Months;
-use chrono::NaiveDateTime;
-use chrono::TimeZone;
 use chrono::Timelike;
 
 use crate::expressions::types::CellReferenceIndex;
@@ -258,8 +257,8 @@ impl Model {
         // milliseconds since January 1, 1970 00:00:00 UTC.
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
-        let dt = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
-            Some(dt) => dt,
+        let local_time = match DateTime::from_timestamp(seconds, 0) {
+            Some(dt) => dt.with_timezone(&self.tz),
             None => {
                 return CalcResult::Error {
                     error: Error::ERROR,
@@ -268,7 +267,6 @@ impl Model {
                 }
             }
         };
-        let local_time = self.tz.from_utc_datetime(&dt);
         // 693_594 is computed as:
         // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
         // The 2 days offset is because of Excel 1900 bug
@@ -289,8 +287,8 @@ impl Model {
         // milliseconds since January 1, 1970 00:00:00 UTC.
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
-        let dt = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
-            Some(dt) => dt,
+        let local_time = match DateTime::from_timestamp(seconds, 0) {
+            Some(dt) => dt.with_timezone(&self.tz),
             None => {
                 return CalcResult::Error {
                     error: Error::ERROR,
@@ -299,7 +297,6 @@ impl Model {
                 }
             }
         };
-        let local_time = self.tz.from_utc_datetime(&dt);
         // 693_594 is computed as:
         // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
         // The 2 days offset is because of Excel 1900 bug

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/information.rs

@@ -165,7 +165,8 @@ impl Model {
                     message: "argument must be a reference to a single cell".to_string(),
                 };
             }
-            let is_formula = if let Ok(f) = self.cell_formula(left.sheet, left.row, left.column) {
+            let is_formula = if let Ok(f) = self.get_cell_formula(left.sheet, left.row, left.column)
+            {
                 f.is_some()
             } else {
                 false

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

@@ -1,4 +1,5 @@
 use core::fmt;
+use std::array::IntoIter;
 
 use crate::{
     calc_result::CalcResult,
@@ -74,6 +75,7 @@ pub enum Function {
 
     // Information
     ErrorType,
+    Formulatext,
     Isblank,
     Iserr,
     Iserror,
@@ -121,6 +123,7 @@ pub enum Function {
     Textbefore,
     Textjoin,
     Trim,
+    Unicode,
     Upper,
     Value,
     Valuetotext,
@@ -244,6 +247,208 @@ pub enum Function {
     Subtotal,
 }
 
+impl Function {
+    pub fn into_iter() -> IntoIter<Function, 194> {
+        [
+            Function::And,
+            Function::False,
+            Function::If,
+            Function::Iferror,
+            Function::Ifna,
+            Function::Ifs,
+            Function::Not,
+            Function::Or,
+            Function::Switch,
+            Function::True,
+            Function::Xor,
+            Function::Sin,
+            Function::Cos,
+            Function::Tan,
+            Function::Asin,
+            Function::Acos,
+            Function::Atan,
+            Function::Sinh,
+            Function::Cosh,
+            Function::Tanh,
+            Function::Asinh,
+            Function::Acosh,
+            Function::Atanh,
+            Function::Abs,
+            Function::Pi,
+            Function::Sqrt,
+            Function::Sqrtpi,
+            Function::Atan2,
+            Function::Power,
+            Function::Max,
+            Function::Min,
+            Function::Product,
+            Function::Rand,
+            Function::Randbetween,
+            Function::Round,
+            Function::Rounddown,
+            Function::Roundup,
+            Function::Sum,
+            Function::Sumif,
+            Function::Sumifs,
+            Function::Choose,
+            Function::Column,
+            Function::Columns,
+            Function::Index,
+            Function::Indirect,
+            Function::Hlookup,
+            Function::Lookup,
+            Function::Match,
+            Function::Offset,
+            Function::Row,
+            Function::Rows,
+            Function::Vlookup,
+            Function::Xlookup,
+            Function::Concatenate,
+            Function::Exact,
+            Function::Value,
+            Function::T,
+            Function::Valuetotext,
+            Function::Concat,
+            Function::Find,
+            Function::Left,
+            Function::Len,
+            Function::Lower,
+            Function::Mid,
+            Function::Right,
+            Function::Search,
+            Function::Text,
+            Function::Trim,
+            Function::Unicode,
+            Function::Upper,
+            Function::Isnumber,
+            Function::Isnontext,
+            Function::Istext,
+            Function::Islogical,
+            Function::Isblank,
+            Function::Iserr,
+            Function::Iserror,
+            Function::Isna,
+            Function::Na,
+            Function::Isref,
+            Function::Isodd,
+            Function::Iseven,
+            Function::ErrorType,
+            Function::Formulatext,
+            Function::Isformula,
+            Function::Type,
+            Function::Sheet,
+            Function::Average,
+            Function::Averagea,
+            Function::Averageif,
+            Function::Averageifs,
+            Function::Count,
+            Function::Counta,
+            Function::Countblank,
+            Function::Countif,
+            Function::Countifs,
+            Function::Maxifs,
+            Function::Minifs,
+            Function::Year,
+            Function::Day,
+            Function::Month,
+            Function::Eomonth,
+            Function::Date,
+            Function::Edate,
+            Function::Today,
+            Function::Now,
+            Function::Pmt,
+            Function::Pv,
+            Function::Rate,
+            Function::Nper,
+            Function::Fv,
+            Function::Ppmt,
+            Function::Ipmt,
+            Function::Npv,
+            Function::Mirr,
+            Function::Irr,
+            Function::Xirr,
+            Function::Xnpv,
+            Function::Rept,
+            Function::Textafter,
+            Function::Textbefore,
+            Function::Textjoin,
+            Function::Substitute,
+            Function::Ispmt,
+            Function::Rri,
+            Function::Sln,
+            Function::Syd,
+            Function::Nominal,
+            Function::Effect,
+            Function::Pduration,
+            Function::Tbillyield,
+            Function::Tbillprice,
+            Function::Tbilleq,
+            Function::Dollarde,
+            Function::Dollarfr,
+            Function::Ddb,
+            Function::Db,
+            Function::Cumprinc,
+            Function::Cumipmt,
+            Function::Besseli,
+            Function::Besselj,
+            Function::Besselk,
+            Function::Bessely,
+            Function::Erf,
+            Function::ErfPrecise,
+            Function::Erfc,
+            Function::ErfcPrecise,
+            Function::Bin2dec,
+            Function::Bin2hex,
+            Function::Bin2oct,
+            Function::Dec2Bin,
+            Function::Dec2hex,
+            Function::Dec2oct,
+            Function::Hex2bin,
+            Function::Hex2dec,
+            Function::Hex2oct,
+            Function::Oct2bin,
+            Function::Oct2dec,
+            Function::Oct2hex,
+            Function::Bitand,
+            Function::Bitlshift,
+            Function::Bitor,
+            Function::Bitrshift,
+            Function::Bitxor,
+            Function::Complex,
+            Function::Imabs,
+            Function::Imaginary,
+            Function::Imargument,
+            Function::Imconjugate,
+            Function::Imcos,
+            Function::Imcosh,
+            Function::Imcot,
+            Function::Imcsc,
+            Function::Imcsch,
+            Function::Imdiv,
+            Function::Imexp,
+            Function::Imln,
+            Function::Imlog10,
+            Function::Imlog2,
+            Function::Impower,
+            Function::Improduct,
+            Function::Imreal,
+            Function::Imsec,
+            Function::Imsech,
+            Function::Imsin,
+            Function::Imsinh,
+            Function::Imsqrt,
+            Function::Imsub,
+            Function::Imsum,
+            Function::Imtan,
+            Function::Convert,
+            Function::Delta,
+            Function::Gestep,
+            Function::Subtotal,
+        ]
+        .into_iter()
+    }
+}
+
 impl Function {
     /// Some functions in Excel like CONCAT are stringified as `_xlfn.CONCAT`.
     pub fn to_xlsx_string(&self) -> String {
@@ -259,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(),
@@ -278,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(),
         }
     }
@@ -366,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),
@@ -387,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),
@@ -578,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"),
@@ -592,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"),
@@ -708,7 +919,23 @@ impl fmt::Display for Function {
     }
 }
 
+/// Documentation for one function
+pub struct Documentation {
+    pub name: String,
+}
+
 impl Model {
+    /// Produces documentation for all implemented functions
+    pub fn documentation() -> Vec<Documentation> {
+        let mut doc = Vec::new();
+        for function in Function::into_iter() {
+            doc.push(Documentation {
+                name: function.to_string(),
+            });
+        }
+        doc
+    }
+
     pub(crate) fn evaluate_function(
         &mut self,
         kind: &Function,
@@ -795,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),
@@ -810,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),
@@ -928,3 +1157,67 @@ impl Model {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+    use std::{
+        fs::File,
+        io::{BufRead, BufReader},
+    };
+
+    use crate::functions::Function;
+
+    #[test]
+    fn function_iterator() {
+        // This checks that the number of functions in the enum is the same
+        // as the number of functions in the Iterator.
+
+        // This is tricky. In Rust we cannot loop over all the members of an enum.
+        // There are alternatives like using an external crate like strum.
+        // But I am not in the mood for that.
+
+        // What we do here is read this file , extract the functions in the enum
+        // and check they are the same as in the iterator
+        let file = File::open("src/functions/mod.rs").unwrap();
+        let reader = BufReader::new(file);
+        let mut start = false;
+        let mut list = Vec::new();
+
+        for line in reader.lines() {
+            let text = line.unwrap();
+            let text = text.trim().trim_end_matches(',');
+            if text == "pub enum Function {" {
+                start = true;
+                continue;
+            }
+            if start {
+                if text == "}" {
+                    break;
+                }
+                if text.starts_with("//") {
+                    // skip comments
+                    continue;
+                }
+                if text.is_empty() {
+                    // skip empty lines
+                    continue;
+                }
+                list.push(text.to_owned());
+            }
+        }
+        // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
+        let iter_list = Function::into_iter()
+            .map(|f| format!("{}", f).replace('.', ""))
+            .collect::<Vec<_>>();
+
+        let len = iter_list.len();
+
+        assert_eq!(list.len(), len);
+        // We still need to check there are no duplicates. This will fail if a function in iter_list
+        // is included twice and one is missing
+        for function in list {
+            assert!(iter_list.contains(&function.to_uppercase()));
+        }
+    }
+}

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,20 +1,17 @@
-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 {
-    #[serde(rename = "true")]
-    pub true_value: String,
-    #[serde(rename = "false")]
-    pub false_value: String,
+    pub r#true: String,
+    pub r#false: String,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Errors {
-    #[serde(rename = "ref")]
-    pub ref_value: String,
+    pub r#ref: String,
     pub name: String,
     pub value: String,
     pub div: String,
@@ -28,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

@@ -8,7 +8,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! ironcalc_base = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
+//! ironcalc_base = { git = "https://github.com/ironcalc/IronCalc" }
 //! ```
 //!
 //! <small> until version 0.5.0 you should use the git dependencies as stated </small>
@@ -31,23 +31,21 @@ pub mod expressions;
 pub mod formatter;
 pub mod language;
 pub mod locale;
-pub mod model;
 pub mod new_empty;
 pub mod number_format;
 pub mod types;
 pub mod worksheet;
 
-mod functions;
-
 mod actions;
 mod cast;
 mod constants;
-mod styles;
-
 mod diffs;
+mod functions;
 mod implicit_intersection;
-
+mod model;
+mod styles;
 mod units;
+mod user_model;
 mod utils;
 mod workbook;
 
@@ -56,3 +54,9 @@ mod test;
 
 #[cfg(test)]
 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,40 +50,27 @@ 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> {
+pub fn get_locale(id: &str) -> Result<&Locale, String> {
     // TODO: pass the locale once we implement locales in Rust
-    let locale = LOCALES.get("en").ok_or("Invalid locale")?;
-    Ok(locale)
-}
-
-// TODO: Remove this function one we implement locales properly
-pub fn get_locale_fix(id: &str) -> Result<&Locale, String> {
     let locale = LOCALES.get(id).ok_or("Invalid locale")?;
     Ok(locale)
 }

base/src/mock_time.rs

@@ -10,7 +10,7 @@ use std::cell::RefCell;
 // 8 November 2022 12:13 Berlin time
 
 thread_local! {
-    static MOCK_TIME: RefCell<i64> = RefCell::new(1667906008578);
+    static MOCK_TIME: RefCell<i64> = const { RefCell::new(1667906008578) };
 }
 
 pub fn get_milliseconds_since_epoch() -> i64 {
@@ -20,3 +20,18 @@ pub fn get_milliseconds_since_epoch() -> i64 {
 pub fn set_mock_time(time: i64) {
     MOCK_TIME.with(|cell| *cell.borrow_mut() = time);
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::mock_time::MOCK_TIME;
+
+    use super::get_milliseconds_since_epoch;
+
+    #[test]
+    fn mock_time() {
+        let t = get_milliseconds_since_epoch();
+        assert_eq!(t, 1667906008578);
+
+        MOCK_TIME.with_borrow(|v| assert_eq!(*v, 1667906008578));
+    }
+}

base/src/new_empty.rs

@@ -1,19 +1,24 @@
-use chrono::NaiveDateTime;
+use chrono::DateTime;
 
 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,8 +142,8 @@ impl Model {
         self.parsed_defined_names = parsed_defined_names;
     }
 
-    // Reparses all formulas and defined names
-    fn reset_parsed_structures(&mut self) {
+    /// Reparses all formulas and defined names
+    pub(crate) fn reset_parsed_structures(&mut self) {
         self.parser
             .set_worksheets(self.workbook.get_worksheet_names());
         self.parsed_formulas = vec![];
@@ -134,10 +154,10 @@ impl Model {
     }
 
     /// Adds a sheet with a automatically generated name
-    pub fn new_sheet(&mut self) {
+    pub fn new_sheet(&mut self) -> (String, u32) {
         // First we find a name
 
-        // TODO: When/if we support i18n the name could depend on the locale
+        // TODO: The name should depend on the locale
         let base_name = "Sheet";
         let base_name_uppercase = base_name.to_uppercase();
         let mut index = 1;
@@ -153,9 +173,11 @@ 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)
     }
 
     /// Inserts a sheet with a particular index
@@ -183,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());
         }
@@ -223,10 +246,10 @@ impl Model {
         new_name: &str,
     ) -> Result<(), String> {
         if !is_valid_sheet_name(new_name) {
-            return Err(format!("Invalid name for a sheet: '{}'", new_name));
+            return Err(format!("Invalid name for a sheet: '{}'.", new_name));
         }
         if self.get_sheet_index_by_name(new_name).is_some() {
-            return Err(format!("Sheet already exists: '{}'", new_name));
+            return Err(format!("Sheet already exists: '{}'.", new_name));
         }
         let worksheets = &self.workbook.worksheets;
         let sheet_count = worksheets.len() as u32;
@@ -270,7 +293,7 @@ impl Model {
         if sheet_count == 1 {
             return Err("Cannot delete only sheet".to_string());
         };
-        if sheet_index > sheet_count {
+        if sheet_index >= sheet_count {
             return Err("Sheet index too large".to_string());
         }
         self.workbook.worksheets.remove(sheet_index as usize);
@@ -323,18 +346,28 @@ impl Model {
 
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
-        let dt = match NaiveDateTime::from_timestamp_opt(seconds, 0) {
+        let dt = match DateTime::from_timestamp(seconds, 0) {
             Some(s) => s,
             None => return Err(format!("Invalid timestamp: {}", milliseconds)),
         };
         // "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 {
@@ -350,6 +383,7 @@ impl Model {
                 last_modified: now,
             },
             tables: HashMap::new(),
+            views,
         };
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
@@ -358,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 {
@@ -370,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

@@ -1,6 +1,7 @@
 mod test_actions;
 mod test_binary_search;
 mod test_cell;
+mod test_cell_clear_contents;
 mod test_circular_references;
 mod test_column_width;
 mod test_criteria;
@@ -14,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;
@@ -23,14 +25,14 @@ 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;
 mod test_math;
 mod test_metadata;
-mod test_model_delete_cell;
+mod test_model_cell_clear_all;
 mod test_model_is_empty_cell;
-mod test_model_set_cell_empty;
 mod test_move_formula;
 mod test_quote_prefix;
 mod test_set_user_input;
@@ -51,5 +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,8 +1,9 @@
 #![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;
 
 #[test]
 fn test_insert_columns() {
@@ -86,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
@@ -105,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
@@ -119,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
@@ -138,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
@@ -195,6 +200,250 @@ fn test_delete_columns() {
     assert_eq!(model._get_formula("A3"), *"=SUM(#REF!:K4)");
 }
 
+#[test]
+fn test_delete_column_width() {
+    let mut model = new_empty_model();
+    let (sheet, column) = (0, 5);
+    let normal_width = model.get_column_width(sheet, column).unwrap();
+    // Set the width of one column to 5 times the normal width
+    assert!(model
+        .set_column_width(sheet, column, normal_width * 5.0)
+        .is_ok());
+
+    // delete it
+    assert!(model.delete_columns(sheet, column, 1).is_ok());
+
+    // all the columns around have the expected width
+    assert_eq!(
+        model.get_column_width(sheet, column - 1).unwrap(),
+        normal_width
+    );
+    assert_eq!(model.get_column_width(sheet, column).unwrap(), normal_width);
+    assert_eq!(
+        model.get_column_width(sheet, column + 1).unwrap(),
+        normal_width
+    );
+}
+
+#[test]
+// We set the style of columns 4 to 7 and delete column 4
+// We check that columns 4 to 6 have the new style
+fn test_delete_first_column_width() {
+    let mut model = new_empty_model();
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 4,
+        max: 7,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+    let (sheet, column) = (0, 4);
+    assert!(model.delete_columns(sheet, column, 1).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 4,
+            max: 6,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+// Delete the last column in the range
+fn test_delete_last_column_width() {
+    let mut model = new_empty_model();
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 4,
+        max: 7,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+    let (sheet, column) = (0, 7);
+    assert!(model.delete_columns(sheet, column, 1).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 4,
+            max: 6,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+// Deletes columns at the end
+fn test_delete_last_few_columns_width() {
+    let mut model = new_empty_model();
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 4,
+        max: 17,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+    let (sheet, column) = (0, 13);
+    assert!(model.delete_columns(sheet, column, 10).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 4,
+            max: 12,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+fn test_delete_columns_non_overlapping_left() {
+    let mut model = new_empty_model();
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 10,
+        max: 17,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+    let (sheet, column) = (0, 3);
+    assert!(model.delete_columns(sheet, column, 4).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 6,
+            max: 13,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+fn test_delete_columns_overlapping_left() {
+    let mut model = new_empty_model();
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 10,
+        max: 20,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+    let (sheet, column) = (0, 8);
+    assert!(model.delete_columns(sheet, column, 4).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 8,
+            max: 16,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+fn test_delete_columns_non_overlapping_right() {
+    let mut model = new_empty_model();
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 10,
+        max: 17,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+    let (sheet, column) = (0, 23);
+    assert!(model.delete_columns(sheet, column, 4).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 10,
+            max: 17,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+// deletes some columns in the middle of the range
+fn test_delete_middle_column_width() {
+    let mut model = new_empty_model();
+    // styled columns [4, 17]
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 4,
+        max: 17,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+
+    // deletes columns 10, 11, 12
+    let (sheet, column) = (0, 10);
+    assert!(model.delete_columns(sheet, column, 3).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 1);
+    assert_eq!(
+        cols[0],
+        Col {
+            min: 4,
+            max: 14,
+            width: 300.0,
+            custom_width: true,
+            style: None
+        }
+    );
+}
+
+#[test]
+// the range is inside the deleted columns
+fn delete_range_in_columns() {
+    let mut model = new_empty_model();
+    // styled columns [6, 10]
+    model.workbook.worksheets[0].cols = vec![Col {
+        min: 6,
+        max: 10,
+        width: 300.0,
+        custom_width: true,
+        style: None,
+    }];
+
+    // deletes columns [4, 17]
+    let (sheet, column) = (0, 4);
+    assert!(model.delete_columns(sheet, column, 8).is_ok());
+    let cols = &model.workbook.worksheets[0].cols;
+    assert_eq!(cols.len(), 0);
+}
+
+#[test]
+fn test_delete_columns_error() {
+    let mut model = new_empty_model();
+    let (sheet, column) = (0, 5);
+    assert!(model.delete_columns(sheet, column, -1).is_err());
+    assert!(model.delete_columns(sheet, column, 0).is_err());
+    assert!(model.delete_columns(sheet, column, 1).is_ok());
+}
+
 #[test]
 fn test_delete_rows() {
     let mut model = new_empty_model();

base/src/test/test_cell_clear_contents.rs

@@ -2,25 +2,25 @@
 use crate::test::util::new_empty_model;
 
 #[test]
-fn test_set_cell_empty_non_existing_sheet() {
+fn test_cell_clear_contents_non_existing_sheet() {
     let mut model = new_empty_model();
     assert_eq!(
-        model.set_cell_empty(13, 1, 1),
+        model.cell_clear_contents(13, 1, 1),
         Err("Invalid sheet index".to_string())
     );
 }
 
 #[test]
-fn test_set_cell_empty_unset_cell() {
+fn test_cell_clear_contents_unset_cell() {
     let mut model = new_empty_model();
-    model.set_cell_empty(0, 1, 1).unwrap();
+    model.cell_clear_contents(0, 1, 1).unwrap();
     assert_eq!(model.is_empty_cell(0, 1, 1), Ok(true));
     model.evaluate();
     assert_eq!(model._get_text_at(0, 1, 1), "");
 }
 
 #[test]
-fn test_set_cell_empty_with_value() {
+fn test_cell_clear_contents_with_value() {
     let mut model = new_empty_model();
     model._set("A1", "hello");
     model.evaluate();
@@ -28,7 +28,7 @@ fn test_set_cell_empty_with_value() {
     assert_eq!(model._get_text_at(0, 1, 1), "hello");
     assert_eq!(model.is_empty_cell(0, 1, 1), Ok(false));
 
-    model.set_cell_empty(0, 1, 1).unwrap();
+    model.cell_clear_contents(0, 1, 1).unwrap();
     model.evaluate();
 
     assert_eq!(model._get_text_at(0, 1, 1), "");
@@ -36,7 +36,7 @@ fn test_set_cell_empty_with_value() {
 }
 
 #[test]
-fn test_set_cell_empty_referenced_elsewhere() {
+fn test_cell_clear_contents_referenced_elsewhere() {
     let mut model = new_empty_model();
     model._set("A1", "35");
     model._set("A2", "=2*A1");
@@ -47,7 +47,7 @@ fn test_set_cell_empty_referenced_elsewhere() {
     assert_eq!(model.is_empty_cell(0, 1, 1), Ok(false));
     assert_eq!(model.is_empty_cell(0, 2, 1), Ok(false));
 
-    model.set_cell_empty(0, 1, 1).unwrap();
+    model.cell_clear_contents(0, 1, 1).unwrap();
     model.evaluate();
 
     assert_eq!(model._get_text_at(0, 1, 1), "");

base/src/test/test_column_width.rs

@@ -23,10 +23,10 @@ fn test_column_width() {
         .unwrap();
     assert_eq!(model.workbook.worksheets[0].cols.len(), 3);
     let worksheet = model.workbook.worksheet(0).unwrap();
-    assert!((worksheet.column_width(1).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert!((worksheet.column_width(2).unwrap() - 30.0).abs() < f64::EPSILON);
-    assert!((worksheet.column_width(3).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 2), 6);
+    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), Ok(6));
 }
 
 #[test]
@@ -48,10 +48,12 @@ fn test_column_width_lower_edge() {
         .unwrap();
     assert_eq!(model.workbook.worksheets[0].cols.len(), 2);
     let worksheet = model.workbook.worksheet(0).unwrap();
-    assert!((worksheet.column_width(4).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert!((worksheet.column_width(5).unwrap() - 30.0).abs() < f64::EPSILON);
-    assert!((worksheet.column_width(6).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 5), 1);
+    assert!((worksheet.get_column_width(4).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
+    assert!((worksheet.get_column_width(5).unwrap() - 30.0).abs() < f64::EPSILON);
+    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), Ok(1));
 }
 
 #[test]
@@ -74,9 +76,9 @@ fn test_column_width_higher_edge() {
     assert_eq!(model.workbook.worksheets[0].cols.len(), 2);
     let worksheet = model.workbook.worksheet(0).unwrap();
     assert!(
-        (worksheet.column_width(15).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
+        (worksheet.get_column_width(15).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
     );
-    assert!((worksheet.column_width(16).unwrap() - 30.0).abs() < f64::EPSILON);
-    assert!((worksheet.column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 16), 1);
+    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), 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_frozen_rows_and_columns.rs

@@ -8,34 +8,37 @@ use crate::{
 #[test]
 fn test_empty_model() {
     let mut model = new_empty_model();
-    assert_eq!(model.get_frozen_rows(0), Ok(0));
-    assert_eq!(model.get_frozen_columns(0), Ok(0));
+    assert_eq!(model.get_frozen_rows_count(0), Ok(0));
+    assert_eq!(model.get_frozen_columns_count(0), Ok(0));
 
     let e = model.set_frozen_rows(0, 3);
     assert!(e.is_ok());
-    assert_eq!(model.get_frozen_rows(0), Ok(3));
-    assert_eq!(model.get_frozen_columns(0), Ok(0));
+    assert_eq!(model.get_frozen_rows_count(0), Ok(3));
+    assert_eq!(model.get_frozen_columns_count(0), Ok(0));
 
     let e = model.set_frozen_columns(0, 53);
     assert!(e.is_ok());
-    assert_eq!(model.get_frozen_rows(0), Ok(3));
-    assert_eq!(model.get_frozen_columns(0), Ok(53));
+    assert_eq!(model.get_frozen_rows_count(0), Ok(3));
+    assert_eq!(model.get_frozen_columns_count(0), Ok(53));
 
     // Set them back to zero
     let e = model.set_frozen_rows(0, 0);
     assert!(e.is_ok());
     let e = model.set_frozen_columns(0, 0);
     assert!(e.is_ok());
-    assert_eq!(model.get_frozen_rows(0), Ok(0));
-    assert_eq!(model.get_frozen_columns(0), Ok(0));
+    assert_eq!(model.get_frozen_rows_count(0), Ok(0));
+    assert_eq!(model.get_frozen_columns_count(0), Ok(0));
 }
 
 #[test]
 fn test_invalid_sheet() {
     let mut model = new_empty_model();
-    assert_eq!(model.get_frozen_rows(1), Err("Invalid sheet".to_string()));
     assert_eq!(
-        model.get_frozen_columns(3),
+        model.get_frozen_rows_count(1),
+        Err("Invalid sheet".to_string())
+    );
+    assert_eq!(
+        model.get_frozen_columns_count(3),
         Err("Invalid sheet".to_string())
     );
 

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,17 +431,17 @@ 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();
 
     model.evaluate();
 
-    assert_eq!(model.formatted_cell_value(0, 1, 1).unwrap(), "foobar");
-    assert_eq!(model.formatted_cell_value(0, 2, 1).unwrap(), "TRUE");
-    assert_eq!(model.formatted_cell_value(0, 3, 1).unwrap(), "");
-    assert_eq!(model.formatted_cell_value(0, 4, 1).unwrap(), "123.456");
-    assert_eq!(model.formatted_cell_value(0, 5, 1).unwrap(), "$123.46");
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "foobar");
+    assert_eq!(model.get_formatted_cell_value(0, 2, 1).unwrap(), "TRUE");
+    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "");
+    assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "123.456");
+    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "$123.46");
 }
 
 #[test]
@@ -426,20 +452,20 @@ fn test_cell_formula() {
     model.evaluate();
 
     assert_eq!(
-        model.cell_formula(0, 1, 1), // A1
+        model.get_cell_formula(0, 1, 1), // A1
         Ok(Some("=1+2+3".to_string())),
     );
     assert_eq!(
-        model.cell_formula(0, 2, 1), // A2
+        model.get_cell_formula(0, 2, 1), // A2
         Ok(None),
     );
     assert_eq!(
-        model.cell_formula(0, 3, 1), // A3 - empty cell
+        model.get_cell_formula(0, 3, 1), // A3 - empty cell
         Ok(None),
     );
 
     assert_eq!(
-        model.cell_formula(42, 1, 1),
+        model.get_cell_formula(42, 1, 1),
         Err("Invalid sheet index".to_string()),
     );
 }
@@ -453,16 +479,16 @@ fn test_xlfn() {
     model.evaluate();
     // Only modern formulas strip the '_xlfn.'
     assert_eq!(
-        model.cell_formula(0, 1, 1).unwrap(),
+        model.get_cell_formula(0, 1, 1).unwrap(),
         Some("=_xlfn.SIN(1)".to_string())
     );
     // unknown formulas keep the '_xlfn.' prefix
     assert_eq!(
-        model.cell_formula(0, 2, 1).unwrap(),
+        model.get_cell_formula(0, 2, 1).unwrap(),
         Some("=_xlfn.SINY(1)".to_string())
     );
     assert_eq!(
-        model.cell_formula(0, 3, 1).unwrap(),
+        model.get_cell_formula(0, 3, 1).unwrap(),
         Some("=CONCAT(3,4)".to_string())
     );
 }
@@ -474,11 +500,11 @@ fn test_letter_case() {
     model._set("A2", "=sIn(2)");
     model.evaluate();
     assert_eq!(
-        model.cell_formula(0, 1, 1).unwrap(),
+        model.get_cell_formula(0, 1, 1).unwrap(),
         Some("=SIN(1)".to_string())
     );
     assert_eq!(
-        model.cell_formula(0, 2, 1).unwrap(),
+        model.get_cell_formula(0, 2, 1).unwrap(),
         Some("=SIN(2)".to_string())
     );
 }

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

@@ -2,22 +2,22 @@
 use crate::test::util::new_empty_model;
 
 #[test]
-fn test_delete_cell_non_existing_sheet() {
+fn test_cell_clear_all_non_existing_sheet() {
     let mut model = new_empty_model();
     assert_eq!(
-        model.delete_cell(13, 1, 1),
+        model.cell_clear_all(13, 1, 1),
         Err("Invalid sheet index".to_string())
     );
 }
 
 #[test]
-fn test_delete_cell_unset_cell() {
+fn test_cell_clear_all_unset_cell() {
     let mut model = new_empty_model();
-    assert!(model.delete_cell(0, 1, 1).is_ok());
+    assert!(model.cell_clear_all(0, 1, 1).is_ok());
 }
 
 #[test]
-fn test_delete_cell_with_value() {
+fn test_cell_clear_all_with_value() {
     let mut model = new_empty_model();
     model._set("A1", "hello");
     model.evaluate();
@@ -25,7 +25,7 @@ fn test_delete_cell_with_value() {
     assert_eq!(model._get_text_at(0, 1, 1), "hello");
     assert_eq!(model.is_empty_cell(0, 1, 1), Ok(false));
 
-    model.delete_cell(0, 1, 1).unwrap();
+    model.cell_clear_all(0, 1, 1).unwrap();
     model.evaluate();
 
     assert_eq!(model._get_text_at(0, 1, 1), "");
@@ -33,7 +33,7 @@ fn test_delete_cell_with_value() {
 }
 
 #[test]
-fn test_delete_cell_referenced_elsewhere() {
+fn test_cell_clear_all_referenced_elsewhere() {
     let mut model = new_empty_model();
     model._set("A1", "35");
     model._set("A2", "=2*A1");
@@ -44,7 +44,7 @@ fn test_delete_cell_referenced_elsewhere() {
     assert_eq!(model.is_empty_cell(0, 1, 1), Ok(false));
     assert_eq!(model.is_empty_cell(0, 2, 1), Ok(false));
 
-    model.delete_cell(0, 1, 1).unwrap();
+    model.cell_clear_all(0, 1, 1).unwrap();
     model.evaluate();
 
     assert_eq!(model._get_text_at(0, 1, 1), "");

base/src/test/test_model_is_empty_cell.rs

@@ -14,9 +14,11 @@ 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.set_cell_empty(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,14 +14,14 @@ 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();
     model.set_cell_style(0, 4, 1, &style).unwrap();
 
     assert_eq!(
-        model.sheet_markup(0),
+        model.get_sheet_markup(0),
         Ok("**Item**|**Cost**\nRent|$600\nElectricity|$200\n**Total**|=SUM(B2:B3)".to_string()),
     )
 }

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());
@@ -236,3 +236,11 @@ fn test_delete_sheet_by_index() {
     assert_eq!(model.workbook.get_worksheet_names(), ["Sheet2"]);
     assert_eq!(model._get_text("Sheet2!A1"), "#REF!");
 }
+
+#[test]
+fn delete_sheet_error() {
+    let mut model = new_empty_model();
+    model.new_sheet();
+    assert!(model.delete_sheet(2).is_err());
+    assert!(model.delete_sheet(1).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_workbook.rs

@@ -1,14 +1,14 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::{test::util::new_empty_model, types::SheetInfo};
+use crate::{test::util::new_empty_model, types::SheetProperties};
 
 #[test]
 fn workbook_worksheets_info() {
     let model = new_empty_model();
-    let sheets_info = model.workbook.get_worksheets_info();
+    let sheets_info = model.get_worksheets_properties();
     assert_eq!(
         sheets_info[0],
-        SheetInfo {
+        SheetProperties {
             name: "Sheet1".to_string(),
             state: "visible".to_string(),
             sheet_id: 1,

base/src/test/test_worksheet.rs

@@ -39,7 +39,7 @@ fn test_worksheet_dimension_single_cell() {
 fn test_worksheet_dimension_single_cell_set_empty() {
     let mut model = new_empty_model();
     model._set("W11", "1");
-    model.set_cell_empty(0, 11, 23).unwrap();
+    model.cell_clear_contents(0, 11, 23).unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -55,7 +55,7 @@ fn test_worksheet_dimension_single_cell_set_empty() {
 fn test_worksheet_dimension_single_cell_deleted() {
     let mut model = new_empty_model();
     model._set("W11", "1");
-    model.delete_cell(0, 11, 23).unwrap();
+    model.cell_clear_all(0, 11, 23).unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -75,7 +75,7 @@ fn test_worksheet_dimension_multiple_cells() {
     model._set("AA17", "1");
     model._set("G17", "1");
     model._set("B19", "1");
-    model.delete_cell(0, 11, 23).unwrap();
+    model.cell_clear_all(0, 11, 23).unwrap();
     assert_eq!(
         model.workbook.worksheet(0).unwrap().dimension(),
         WorksheetDimension {
@@ -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

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

@@ -0,0 +1,104 @@
+#![allow(clippy::unwrap_used)]
+
+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().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().unwrap();
+    model.set_user_input(2, 1, 1, "=Sheet2!B1").unwrap();
+
+    model.undo().unwrap();
+    model.undo().unwrap();
+
+    assert!(model.get_formatted_cell_value(2, 1, 1).is_err());
+
+    model.redo().unwrap();
+    model.redo().unwrap();
+
+    assert_eq!(model.get_formatted_cell_value(2, 1, 1), Ok("6".to_string()));
+
+    model.delete_sheet(1).unwrap();
+
+    assert!(!model.can_undo());
+    assert!(!model.can_redo());
+}
+
+#[test]
+fn set_sheet_color() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_sheet_color(0, "#343434").unwrap();
+    let worksheets_properties = model.get_worksheets_properties();
+    assert_eq!(worksheets_properties.len(), 1);
+    assert_eq!(worksheets_properties[0].color, Some("#343434".to_owned()));
+    model.undo().unwrap();
+    assert_eq!(model.get_worksheets_properties()[0].color, None);
+
+    model.redo().unwrap();
+    assert_eq!(
+        model.get_worksheets_properties()[0].color,
+        Some("#343434".to_owned())
+    );
+    // changes the color if there is one
+    model.set_sheet_color(0, "#2534FF").unwrap();
+    assert_eq!(
+        model.get_worksheets_properties()[0].color,
+        Some("#2534FF".to_owned())
+    );
+    // Setting it back to none
+    model.set_sheet_color(0, "").unwrap();
+    assert_eq!(model.get_worksheets_properties()[0].color, None);
+}
+
+#[test]
+fn new_sheet_propagates() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.new_sheet().unwrap();
+
+    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 worksheets_properties = model2.get_worksheets_properties();
+    assert_eq!(worksheets_properties.len(), 2);
+}
+
+#[test]
+fn delete_sheet_propagates() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.new_sheet().unwrap();
+    model.delete_sheet(0).unwrap();
+
+    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 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_clear_cells.rs

@@ -0,0 +1,91 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{expressions::types::Area, UserModel};
+
+#[test]
+fn basic() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "100$").unwrap();
+    model
+        .range_clear_contents(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+    model.undo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("100$".to_string())
+    );
+    model.redo().unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+
+    model.set_user_input(0, 1, 1, "300").unwrap();
+    // clear contents keeps the formatting
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("300$".to_string())
+    );
+
+    model
+        .range_clear_all(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+    model.undo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("300$".to_string())
+    );
+    model.redo().unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+    model.set_user_input(0, 1, 1, "400").unwrap();
+    // clear contents keeps the formatting
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("400".to_string())
+    );
+}
+
+#[test]
+fn clear_empty_cell() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model
+        .range_clear_contents(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+    model.undo().unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+}
+
+#[test]
+fn clear_all_empty_cell() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model
+        .range_clear_all(&Area {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            width: 1,
+            height: 1,
+        })
+        .unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+    model.undo().unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
+}

base/src/test/user_model/test_diff_queue.rs

@@ -0,0 +1,163 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn send_queue() {
+    let mut model1 = UserModel::from_model(new_empty_model());
+    let width = model1.get_column_width(0, 3).unwrap() * 3.0;
+    model1.set_column_width(0, 3, width).unwrap();
+    model1.set_user_input(0, 1, 2, "Hello IronCalc!").unwrap();
+    let send_queue = model1.flush_send_queue();
+
+    let mut model2 = UserModel::from_model(new_empty_model());
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(model2.get_column_width(0, 3), Ok(width));
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello IronCalc!".to_string())
+    );
+}
+
+#[test]
+fn apply_external_diffs_wrong_str() {
+    let mut model1 = UserModel::from_model(new_empty_model());
+    assert!(model1.apply_external_diffs("invalid".as_bytes()).is_err());
+}
+
+#[test]
+fn queue_undo_redo() {
+    let mut model1 = UserModel::from_model(new_empty_model());
+    let width = model1.get_column_width(0, 3).unwrap() * 3.0;
+    model1.set_column_width(0, 3, width).unwrap();
+    model1.set_user_input(0, 1, 2, "Hello IronCalc!").unwrap();
+    assert!(model1.undo().is_ok());
+    assert!(model1.redo().is_ok());
+    let send_queue = model1.flush_send_queue();
+
+    let mut model2 = UserModel::from_model(new_empty_model());
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(model2.get_column_width(0, 3), Ok(width));
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 1, 2),
+        Ok("Hello IronCalc!".to_string())
+    );
+}
+
+#[test]
+fn queue_undo_redo_multiple() {
+    let mut model1 = UserModel::from_model(new_empty_model());
+
+    // do a bunch of things
+    model1.set_frozen_columns_count(0, 5).unwrap();
+    model1.set_frozen_rows_count(0, 6).unwrap();
+    model1.set_column_width(0, 7, 300.0).unwrap();
+    model1.set_row_height(0, 23, 123.0).unwrap();
+    model1.set_user_input(0, 55, 55, "=42+8").unwrap();
+
+    for row in 1..5 {
+        model1.set_user_input(0, row, 17, "=ROW()").unwrap();
+    }
+
+    model1.insert_row(0, 3).unwrap();
+    model1.insert_row(0, 3).unwrap();
+
+    // undo al of them
+    while model1.can_undo() {
+        model1.undo().unwrap();
+    }
+
+    // check it is an empty model
+    assert_eq!(model1.get_frozen_columns_count(0), Ok(0));
+    assert_eq!(model1.get_frozen_rows_count(0), Ok(0));
+    assert_eq!(model1.get_column_width(0, 7), Ok(DEFAULT_COLUMN_WIDTH));
+    assert_eq!(
+        model1.get_formatted_cell_value(0, 55, 55),
+        Ok("".to_string())
+    );
+    assert_eq!(model1.get_row_height(0, 23), Ok(DEFAULT_ROW_HEIGHT));
+    assert_eq!(
+        model1.get_formatted_cell_value(0, 57, 55),
+        Ok("".to_string())
+    );
+    assert_eq!(model1.get_row_height(0, 25), Ok(DEFAULT_ROW_HEIGHT));
+
+    // redo all of them
+    while model1.can_redo() {
+        model1.redo().unwrap();
+    }
+
+    // now send all this to a new model
+    let send_queue = model1.flush_send_queue();
+    let mut model2 = UserModel::from_model(new_empty_model());
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    // Check everything is as expected
+    assert_eq!(model2.get_frozen_columns_count(0), Ok(5));
+    assert_eq!(model2.get_frozen_rows_count(0), Ok(6));
+    assert_eq!(model2.get_column_width(0, 7), Ok(300.0));
+    // I inserted two rows
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 57, 55),
+        Ok("50".to_string())
+    );
+    assert_eq!(model2.get_row_height(0, 25), Ok(123.0));
+
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 1, 17),
+        Ok("1".to_string())
+    );
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 2, 17),
+        Ok("2".to_string())
+    );
+
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 3, 17),
+        Ok("".to_string())
+    );
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 4, 17),
+        Ok("".to_string())
+    );
+
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 5, 17),
+        Ok("5".to_string())
+    );
+    assert_eq!(
+        model2.get_formatted_cell_value(0, 6, 17),
+        Ok("6".to_string())
+    );
+}
+
+#[test]
+fn new_sheet() {
+    let mut model1 = UserModel::from_model(new_empty_model());
+    model1.new_sheet().unwrap();
+    model1.set_user_input(0, 1, 1, "42").unwrap();
+    model1.set_user_input(1, 1, 1, "=Sheet1!A1*2").unwrap();
+
+    let send_queue = model1.flush_send_queue();
+    let mut model2 = UserModel::from_model(new_empty_model());
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(
+        model2.get_formatted_cell_value(1, 1, 1),
+        Ok("84".to_string())
+    );
+}
+
+#[test]
+fn wrong_diffs_handled() {
+    let mut model = UserModel::from_model(new_empty_model());
+    assert!(model
+        .apply_external_diffs("Hello world".as_bytes())
+        .is_err());
+}

base/src/test/user_model/test_evaluation.rs

@@ -0,0 +1,31 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::UserModel;
+
+#[test]
+fn model_evaluates_automatically() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "=1 + 1").unwrap();
+
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("2".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("=1+1".to_string()));
+}
+
+#[test]
+fn pause_resume_evaluation() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.pause_evaluation();
+    model.set_user_input(0, 1, 1, "=1+1").unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 1),
+        Ok("#ERROR!".to_string())
+    );
+    model.evaluate();
+
+    assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("2".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("=1+1".to_string()));
+
+    model.resume_evaluation();
+    model.set_user_input(0, 2, 1, "=1+4").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 2, 1), Ok("5".to_string()));
+}

base/src/test/user_model/test_general.rs

@@ -0,0 +1,140 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::test::util::new_empty_model;
+use crate::types::CellType;
+use crate::UserModel;
+
+#[test]
+fn set_user_input_errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // Wrong sheet
+    assert!(model.set_user_input(1, 1, 1, "1").is_err());
+    // Wrong row
+    assert!(model.set_user_input(0, 0, 1, "1").is_err());
+    // Wrong column
+    assert!(model.set_user_input(0, 1, 0, "1").is_err());
+    // row too large
+    assert!(model.set_user_input(0, LAST_ROW, 1, "1").is_ok());
+    assert!(model.set_user_input(0, LAST_ROW + 1, 1, "1").is_err());
+    // column too large
+    assert!(model.set_user_input(0, 1, LAST_COLUMN, "1").is_ok());
+    assert!(model.set_user_input(0, 1, LAST_COLUMN + 1, "1").is_err());
+}
+
+#[test]
+fn user_model_debug_message() {
+    let model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    let s = &format!("{:?}", model);
+    assert_eq!(s, "UserModel");
+}
+
+#[test]
+fn cell_type() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "1").unwrap();
+    model.set_user_input(0, 1, 2, "Wish you were here").unwrap();
+    model.set_user_input(0, 1, 3, "true").unwrap();
+    model.set_user_input(0, 1, 4, "=1/0").unwrap();
+
+    assert_eq!(model.get_cell_type(0, 1, 1).unwrap(), CellType::Number);
+    assert_eq!(model.get_cell_type(0, 1, 2).unwrap(), CellType::Text);
+    assert_eq!(
+        model.get_cell_type(0, 1, 3).unwrap(),
+        CellType::LogicalValue
+    );
+    assert_eq!(model.get_cell_type(0, 1, 4).unwrap(), CellType::ErrorValue);
+
+    // empty cells are number type
+    assert_eq!(model.get_cell_type(0, 40, 40).unwrap(), CellType::Number);
+}
+
+#[test]
+fn insert_remove_rows() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let height = model.get_row_height(0, 5).unwrap();
+
+    // Insert some data in row 5 (and change the style)
+    assert!(model.set_user_input(0, 5, 1, "100$").is_ok());
+    // Change the height of the column
+    assert!(model.set_row_height(0, 5, 3.0 * height).is_ok());
+
+    // remove the row
+    assert!(model.delete_row(0, 5).is_ok());
+    // Row 5 has now the normal height
+    assert_eq!(model.get_row_height(0, 5), Ok(height));
+    // There is no value in A5
+    assert_eq!(model.get_formatted_cell_value(0, 5, 1), Ok("".to_string()));
+    // Setting a value will not format it
+    assert!(model.set_user_input(0, 5, 1, "125").is_ok());
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("125".to_string())
+    );
+
+    // undo twice
+    assert!(model.undo().is_ok());
+    assert!(model.undo().is_ok());
+
+    assert_eq!(model.get_row_height(0, 5), Ok(3.0 * height));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("100$".to_string())
+    );
+}
+
+#[test]
+fn insert_remove_columns() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // column E
+    let column_width = model.get_column_width(0, 5).unwrap();
+    println!("{column_width}");
+
+    // Insert some data in row 5 (and change the style) in E1
+    assert!(model.set_user_input(0, 1, 5, "100$").is_ok());
+    // Change the width of the column
+    assert!(model.set_column_width(0, 5, 3.0 * column_width).is_ok());
+    assert_eq!(model.get_column_width(0, 5).unwrap(), 3.0 * column_width);
+
+    // remove the column
+    assert!(model.delete_column(0, 5).is_ok());
+    // Column 5 has now the normal width
+    assert_eq!(model.get_column_width(0, 5), Ok(column_width));
+    // There is no value in E5
+    assert_eq!(model.get_formatted_cell_value(0, 1, 5), Ok("".to_string()));
+    // Setting a value will not format it
+    assert!(model.set_user_input(0, 1, 5, "125").is_ok());
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 5),
+        Ok("125".to_string())
+    );
+
+    // undo twice (set_user_input and delete_column)
+    assert!(model.undo().is_ok());
+    assert!(model.undo().is_ok());
+
+    assert_eq!(model.get_column_width(0, 5), Ok(3.0 * column_width));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 5),
+        Ok("100$".to_string())
+    );
+}
+
+#[test]
+fn delete_remove_cell() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    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);
+}