FIX: adds create user_model_from_bytes

Cargo.lock

@@ -43,15 +43,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "approx"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -423,7 +414,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.6.0"
+version = "0.5.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -439,25 +430,25 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.6.0"
+version = "0.5.0"
 dependencies = [
  "bitcode",
  "chrono",
  "chrono-tz",
  "csv",
  "js-sys",
+ "once_cell",
  "rand",
  "regex",
  "regex-lite",
  "ryu",
  "serde",
  "serde_json",
- "statrs",
 ]
 
 [[package]]
 name = "ironcalc_nodejs"
-version = "0.6.0"
+version = "0.5.0"
 dependencies = [
  "ironcalc",
  "napi",
@@ -792,7 +783,7 @@ dependencies = [
 
 [[package]]
 name = "pyroncalc"
-version = "0.6.0"
+version = "0.5.6"
 dependencies = [
  "bitcode",
  "ironcalc",
@@ -881,12 +872,6 @@ version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
 
-[[package]]
-name = "rustversion"
-version = "1.0.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
-
 [[package]]
 name = "ryu"
 version = "1.0.17"
@@ -975,16 +960,6 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
-[[package]]
-name = "statrs"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e"
-dependencies = [
- "approx",
- "num-traits",
-]
-
 [[package]]
 name = "subtle"
 version = "2.5.0"
@@ -1095,7 +1070,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm"
-version = "0.6.0"
+version = "0.5.3"
 dependencies = [
  "ironcalc_base",
  "serde",
@@ -1106,24 +1081,23 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
  "cfg-if",
- "once_cell",
- "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
  "bumpalo",
  "log",
+ "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -1144,9 +1118,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1154,9 +1128,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1167,12 +1141,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
-dependencies = [
- "unicode-ident",
-]
 
 [[package]]
 name = "wasm-bindgen-test"

Dockerfile

@@ -1,93 +0,0 @@
-FROM rust:latest AS builder
-
-WORKDIR /app
-COPY . .
-
-# Tools + wasm toolchain + Node via nvm
-RUN apt-get update && apt-get install -y --no-install-recommends \
-      bash curl ca-certificates make \
-    && rustup target add wasm32-unknown-unknown \
-    && cargo install wasm-pack \
-    && bash -lc "curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash -" \
-    && bash -lc '\
-         export NVM_DIR="$HOME/.nvm" && \
-         source "$NVM_DIR/nvm.sh" && \
-         nvm install 22 && nvm alias default 22 && \
-         nroot="$NVM_DIR/versions/node/$(nvm version default)/bin" && \
-         ln -sf "$nroot/node" /usr/local/bin/node && \
-         ln -sf "$nroot/npm"  /usr/local/bin/npm  && \
-         ln -sf "$nroot/npx"  /usr/local/bin/npx \
-       ' \
-    && npm install typescript \
-    && rm -rf /var/lib/apt/lists/*
-
-# build the server
-RUN cargo build --release --manifest-path webapp/app.ironcalc.com/server/Cargo.toml
-
-# build the wasm
-RUN make -C bindings/wasm
-
-# build the widget
-WORKDIR /app/webapp/IronCalc
-RUN npm install && npm run build
-
-# build the frontend app
-WORKDIR /app/webapp/app.ironcalc.com/frontend
-RUN npm install && npm run build
-
-# build the xlsx_2_icalc binary (we don't need the release version here)
-WORKDIR /app/xlsx
-RUN cargo build
-
-WORKDIR /app
-# copy the artifacts to a dist/ directory
-RUN mkdir dist
-RUN mkdir dist/frontend
-RUN cp -r webapp/app.ironcalc.com/frontend/dist/* dist/frontend/
-RUN mkdir dist/server
-RUN cp webapp/app.ironcalc.com/server/target/release/ironcalc_server dist/server/
-RUN cp webapp/app.ironcalc.com/server/Rocket.toml dist/server/
-RUN cp webapp/app.ironcalc.com/server/ironcalc.sqlite dist/server/
-
-# Create ic files in docs
-RUN mkdir -p dist/frontend/models
-
-# Loop over all xlsx files in xlsx/tests/docs & templates and convert them to .ic
-RUN bash -lc 'set -euo pipefail; \
-  mkdir -p dist/frontend/models; \
-  shopt -s nullglob; \
-  for xlsx_file in xlsx/tests/docs/*.xlsx; do \
-    base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
-    ./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
-  done; \
-  for xlsx_file in xlsx/tests/templates/*.xlsx; do \
-    base_name="${xlsx_file##*/}"; base_name="${base_name%.xlsx}"; \
-    ./target/debug/xlsx_2_icalc "$xlsx_file" "dist/frontend/models/${base_name}.ic"; \
-  done'
-
-# ---------- server runtime ----------
-FROM debian:bookworm-slim AS server-runtime
-RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && \
-    rm -rf /var/lib/apt/lists/*
-WORKDIR /app
-# Copy EVERYTHING you put in dist/server (binary + Rocket.toml + DB)
-COPY --from=builder /app/dist/server/ ./
-# Make sure Rocket binds to the container IP; explicitly point to the config file
-ENV ROCKET_ADDRESS=0.0.0.0 \
-    ROCKET_PORT=8000 \
-    ROCKET_CONFIG=/app/Rocket.toml
-EXPOSE 8000
-# Run from /app so relative paths in Rocket.toml/DB work
-CMD ["./ironcalc_server"]
-
-# ---------- caddy runtime (serves frontend + reverse-proxy /api) ----------
-FROM caddy:latest AS caddy-runtime
-
-WORKDIR /srv
-
-# Copy the frontend build output to /srv
-COPY --from=builder /app/dist/frontend/ /srv/
-
-# Copy the Caddyfile
-COPY --from=builder /app/webapp/app.ironcalc.com/Caddyfile.compose /etc/caddy/Caddyfile
-

README.md

@@ -31,17 +31,7 @@ This repository contains the main engine and the xlsx reader and writer.
 
 Programmed in Rust, you will be able to use it from a variety of programming languages like Python, JavaScript (wasm), nodejs and possibly R, Julia or Go.
 
-We will build different _skins_: in the terminal, as a desktop application or use it in your own web application.
+We will build different _skins_: in the terminal, as a desktop application or use it in you own web application.
-
-# Docker
-
-If you have docker installed just run:
-
-```bash
-docker compose up --build
-```
-
-head over to <http://localhost:2080> to test the application.
 
 # Building
 
@@ -94,7 +84,7 @@ And then use this code in `main.rs`:
 
 ```rust
 use ironcalc::{
-    base::{expressions::utils::number_to_column, Model},
+    base::{expressions::utils::number_to_column, model::Model},
     export::save_to_xlsx,
 };
 

base/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ironcalc_base"
-version = "0.6.0"
+version = "0.5.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
@@ -17,9 +17,9 @@ chrono = "0.4"
 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"
-statrs = { version = "0.18.0", default-features = false, features = [] }
 
 [features]
 default = ["use_regex_full"]

base/src/actions.rs

@@ -212,12 +212,6 @@ impl Model {
         if column_count <= 0 {
             return Err("Please use insert columns instead".to_string());
         }
-        if !(1..=LAST_COLUMN).contains(&column) {
-            return Err(format!("Column number '{column}' is not valid."));
-        }
-        if column + column_count - 1 > LAST_COLUMN {
-            return Err("Cannot delete columns beyond the last column of the sheet".to_string());
-        }
 
         // first column being deleted
         let column_start = column;
@@ -390,13 +384,6 @@ impl Model {
         if row_count <= 0 {
             return Err("Please use insert rows instead".to_string());
         }
-        if !(1..=LAST_ROW).contains(&row) {
-            return Err(format!("Row number '{row}' is not valid."));
-        }
-        if row + row_count - 1 > LAST_ROW {
-            return Err("Cannot delete rows beyond the last row of the sheet".to_string());
-        }
-
         // Move cells
         let worksheet = &self.workbook.worksheet(sheet)?;
         let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -457,7 +444,7 @@ impl Model {
     ///    * Column is one of the extremes of the range. The new extreme would be target_column.
     ///      Range is then normalized
     ///    * Any other case, range is left unchanged.
-    ///      NOTE: This moves the data and column styles along with the formulas
+    ///      NOTE: This does NOT move the data in the columns or move the colum styles
     pub fn move_column_action(
         &mut self,
         sheet: u32,
@@ -473,70 +460,7 @@ impl Model {
             return Err("Initial column out of boundaries".to_string());
         }
 
-        if delta == 0 {
+        // TODO: Add the actual displacement of data and styles
-            return Ok(());
-        }
-
-        // Preserve cell contents, width and style of the column being moved
-        let original_refs = self
-            .workbook
-            .worksheet(sheet)?
-            .column_cell_references(column)?;
-        let mut original_cells = Vec::new();
-        for r in &original_refs {
-            let cell = self
-                .workbook
-                .worksheet(sheet)?
-                .cell(r.row, column)
-                .ok_or("Expected Cell to exist")?;
-            let style_idx = cell.get_style();
-            let formula_or_value = self
-                .get_cell_formula(sheet, r.row, column)?
-                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
-            original_cells.push((r.row, formula_or_value, style_idx));
-            self.cell_clear_all(sheet, r.row, column)?;
-        }
-
-        let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
-        let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
-
-        if delta > 0 {
-            for c in column + 1..=target_column {
-                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
-                for r in refs {
-                    self.move_cell(sheet, r.row, c, r.row, c - 1)?;
-                }
-
-                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
-                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .set_column_width_and_style(c - 1, w, s)?;
-            }
-        } else {
-            for c in (target_column..=column - 1).rev() {
-                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
-                for r in refs {
-                    self.move_cell(sheet, r.row, c, r.row, c + 1)?;
-                }
-
-                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
-                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .set_column_width_and_style(c + 1, w, s)?;
-            }
-        }
-
-        for (r, value, style_idx) in original_cells {
-            self.set_user_input(sheet, r, target_column, value)?;
-            self.workbook
-                .worksheet_mut(sheet)?
-                .set_cell_style(r, target_column, style_idx)?;
-        }
-        self.workbook
-            .worksheet_mut(sheet)?
-            .set_column_width_and_style(target_column, width, style)?;
 
         // Update all formulas in the workbook
         self.displace_cells(
@@ -549,88 +473,4 @@ impl Model {
 
         Ok(())
     }
-
-    /// Displaces cells due to a move row action
-    /// from initial_row to target_row = initial_row + row_delta
-    /// References will be updated following the same rules as move_column_action
-    /// NOTE: This moves the data and row styles along with the formulas
-    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
-        // Check boundaries
-        let target_row = row + delta;
-        if !(1..=LAST_ROW).contains(&target_row) {
-            return Err("Target row out of boundaries".to_string());
-        }
-        if !(1..=LAST_ROW).contains(&row) {
-            return Err("Initial row out of boundaries".to_string());
-        }
-
-        if delta == 0 {
-            return Ok(());
-        }
-
-        let original_cols = self.get_columns_for_row(sheet, row, false)?;
-        let mut original_cells = Vec::new();
-        for c in &original_cols {
-            let cell = self
-                .workbook
-                .worksheet(sheet)?
-                .cell(row, *c)
-                .ok_or("Expected Cell to exist")?;
-            let style_idx = cell.get_style();
-            let formula_or_value = self
-                .get_cell_formula(sheet, row, *c)?
-                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
-            original_cells.push((*c, formula_or_value, style_idx));
-            self.cell_clear_all(sheet, row, *c)?;
-        }
-
-        if delta > 0 {
-            for r in row + 1..=target_row {
-                let cols = self.get_columns_for_row(sheet, r, false)?;
-                for c in cols {
-                    self.move_cell(sheet, r, c, r - 1, c)?;
-                }
-            }
-        } else {
-            for r in (target_row..=row - 1).rev() {
-                let cols = self.get_columns_for_row(sheet, r, false)?;
-                for c in cols {
-                    self.move_cell(sheet, r, c, r + 1, c)?;
-                }
-            }
-        }
-
-        for (c, value, style_idx) in original_cells {
-            self.set_user_input(sheet, target_row, c, value)?;
-            self.workbook
-                .worksheet_mut(sheet)?
-                .set_cell_style(target_row, c, style_idx)?;
-        }
-
-        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
-        let mut new_rows = Vec::new();
-        for r in worksheet.rows.iter() {
-            if r.r == row {
-                let mut nr = r.clone();
-                nr.r = target_row;
-                new_rows.push(nr);
-            } else if delta > 0 && r.r > row && r.r <= target_row {
-                let mut nr = r.clone();
-                nr.r -= 1;
-                new_rows.push(nr);
-            } else if delta < 0 && r.r < row && r.r >= target_row {
-                let mut nr = r.clone();
-                nr.r += 1;
-                new_rows.push(nr);
-            } else {
-                new_rows.push(r.clone());
-            }
-        }
-        worksheet.rows = new_rows;
-
-        // Update all formulas in the workbook
-        self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
-
-        Ok(())
-    }
 }

base/src/cast.rs

@@ -5,7 +5,6 @@ use crate::{
         token::Error,
         types::CellReferenceIndex,
     },
-    formatter::format::parse_formatted_number,
     model::Model,
 };
 
@@ -15,23 +14,6 @@ pub(crate) enum NumberOrArray {
 }
 
 impl Model {
-    pub(crate) fn cast_number(&self, s: &str) -> Option<f64> {
-        match s.trim().parse::<f64>() {
-            Ok(f) => Some(f),
-            _ => {
-                let currency = &self.locale.currency.symbol;
-                let mut currencies = vec!["$", "€"];
-                if !currencies.iter().any(|e| *e == currency) {
-                    currencies.push(currency);
-                }
-                // Try to parse as a formatted number (e.g., dates, currencies, percentages)
-                if let Ok((v, _number_format)) = parse_formatted_number(s, &currencies) {
-                    return Some(v);
-                }
-                None
-            }
-        }
-    }
     pub(crate) fn get_number_or_array(
         &mut self,
         node: &Node,
@@ -39,9 +21,9 @@ impl Model {
     ) -> Result<NumberOrArray, CalcResult> {
         match self.evaluate_node_in_context(node, cell) {
             CalcResult::Number(f) => Ok(NumberOrArray::Number(f)),
-            CalcResult::String(s) => match self.cast_number(&s) {
+            CalcResult::String(s) => match s.parse::<f64>() {
-                Some(f) => Ok(NumberOrArray::Number(f)),
+                Ok(f) => Ok(NumberOrArray::Number(f)),
-                None => Err(CalcResult::new_error(
+                _ => Err(CalcResult::new_error(
                     Error::VALUE,
                     cell,
                     "Expecting number".to_string(),
@@ -107,16 +89,16 @@ impl Model {
         self.cast_to_number(result, cell)
     }
 
-    pub(crate) fn cast_to_number(
+    fn cast_to_number(
         &mut self,
         result: CalcResult,
         cell: CellReferenceIndex,
     ) -> Result<f64, CalcResult> {
         match result {
             CalcResult::Number(f) => Ok(f),
-            CalcResult::String(s) => match self.cast_number(&s) {
+            CalcResult::String(s) => match s.parse::<f64>() {
-                Some(f) => Ok(f),
+                Ok(f) => Ok(f),
-                None => Err(CalcResult::new_error(
+                _ => Err(CalcResult::new_error(
                     Error::VALUE,
                     cell,
                     "Expecting number".to_string(),
@@ -177,7 +159,7 @@ impl Model {
         // FIXME: I think when casting a number we should convert it to_precision(x, 15)
         // See function Exact
         match result {
-            CalcResult::Number(f) => Ok(format!("{f}")),
+            CalcResult::Number(f) => Ok(format!("{}", f)),
             CalcResult::String(s) => Ok(s),
             CalcResult::Boolean(f) => {
                 if f {

base/src/expressions/lexer/mod.rs

@@ -142,7 +142,7 @@ impl Lexer {
     pub fn expect(&mut self, tk: TokenType) -> Result<()> {
         let nt = self.next_token();
         if mem::discriminant(&nt) != mem::discriminant(&tk) {
-            return Err(self.set_error(&format!("Error, expected {tk:?}"), self.position));
+            return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position));
         }
         Ok(())
     }
@@ -314,9 +314,6 @@ impl Lexer {
                             } else if name_upper == self.language.booleans.r#false {
                                 return TokenType::Boolean(false);
                             }
-                            if self.peek_char() == Some('(') {
-                                return TokenType::Ident(name);
-                            }
                             if self.mode == LexerMode::A1 {
                                 let parsed_reference = utils::parse_reference_a1(&name_upper);
                                 if parsed_reference.is_some()
@@ -514,7 +511,7 @@ impl Lexer {
         self.position = position;
         chars.parse::<i32>().map_err(|_| LexerError {
             position,
-            message: format!("Failed to parse to int: {chars}"),
+            message: format!("Failed to parse to int: {}", chars),
         })
     }
 
@@ -575,7 +572,9 @@ impl Lexer {
         }
         self.position = position;
         match chars.parse::<f64>() {
-            Err(_) => Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)),
+            Err(_) => {
+                Err(self.set_error(&format!("Failed to parse to double: {}", chars), position))
+            }
             Ok(v) => Ok(v),
         }
     }

base/src/expressions/lexer/ranges.rs

@@ -148,16 +148,15 @@ impl Lexer {
                     let row_left = match row_left.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
-                            return Err(
+                            return Err(self
-                                self.set_error(&format!("Failed parsing row {row_left}"), position)
+                                .set_error(&format!("Failed parsing row {}", row_left), position))
-                            )
                         }
                     };
                     let row_right = match row_right.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
                             return Err(self
-                                .set_error(&format!("Failed parsing row {row_right}"), position))
+                                .set_error(&format!("Failed parsing row {}", row_right), position))
                         }
                     };
                     if row_left > LAST_ROW {

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

@@ -1,6 +1,5 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;
 
@@ -686,29 +685,3 @@ fn test_comparisons() {
     assert_eq!(lx.next_token(), Number(7.0));
     assert_eq!(lx.next_token(), EOF);
 }
-
-#[test]
-fn test_log10_is_cell_reference() {
-    let mut lx = new_lexer("LOG10", true);
-    assert_eq!(
-        lx.next_token(),
-        Reference {
-            sheet: None,
-            column: column_to_number("LOG").unwrap(),
-            row: 10,
-            absolute_column: false,
-            absolute_row: false,
-        }
-    );
-    assert_eq!(lx.next_token(), EOF);
-}
-
-#[test]
-fn test_log10_is_function() {
-    let mut lx = new_lexer("LOG10(100)", true);
-    assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
-    assert_eq!(lx.next_token(), LeftParenthesis);
-    assert_eq!(lx.next_token(), Number(100.0));
-    assert_eq!(lx.next_token(), RightParenthesis);
-    assert_eq!(lx.next_token(), EOF);
-}

base/src/expressions/parser/mod.rs

@@ -717,7 +717,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: format!("sheet not found: {}", context.sheet),
+                            message: "sheet not found".to_string(),
                         };
                     }
                 };
@@ -828,7 +828,7 @@ impl Parser {
             | TokenType::Percent => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
                 position: 0,
-                message: format!("Unexpected token: '{next_token:?}'"),
+                message: format!("Unexpected token: '{:?}'", next_token),
             },
             TokenType::LeftBracket => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
@@ -850,7 +850,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: format!("sheet not found: {}", context.sheet),
+                            message: "sheet not found".to_string(),
                         };
                     }
                 };
@@ -878,7 +878,7 @@ impl Parser {
                         return Node::ParseErrorKind {
                             formula: self.lexer.get_formula(),
                             position: 0,
-                            message: format!("table sheet not found: {}", table.sheet_name),
+                            message: "sheet not found".to_string(),
                         };
                     }
                 };

base/src/expressions/parser/move_formula.rs

@@ -53,24 +53,24 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
             arguments = to_string_moved(el, move_context);
         }
     }
-    format!("{name}({arguments})")
+    format!("{}({})", name, arguments)
 }
 
 pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
     match node {
-        ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(),
+        ArrayNode::Boolean(value) => format!("{}", value).to_ascii_uppercase(),
         ArrayNode::Number(number) => to_excel_precision_str(*number),
-        ArrayNode::String(value) => format!("\"{value}\""),
+        ArrayNode::String(value) => format!("\"{}\"", value),
-        ArrayNode::Error(kind) => format!("{kind}"),
+        ArrayNode::Error(kind) => format!("{}", kind),
     }
 }
 
 fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
+        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
         NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{value}\""),
+        StringKind(value) => format!("\"{}\"", value),
         ReferenceKind {
             sheet_name,
             sheet_index,
@@ -241,7 +241,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         WrongReferenceKind {
             sheet_name,
@@ -325,7 +325,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
@@ -358,7 +358,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 }
                 _ => to_string_moved(right, move_context),
             };
-            format!("{x}{kind}{y}")
+            format!("{}{}{}", x, kind, y)
         }
         OpPowerKind { left, right } => format!(
             "{}^{}",
@@ -403,7 +403,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             }
 
             // Enclose the whole matrix in braces
-            format!("{{{matrix_string}}}")
+            format!("{{{}}}", matrix_string)
         }
         DefinedNameKind((name, ..)) => name.to_string(),
         TableNameKind(name) => name.to_string(),
@@ -418,7 +418,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)),
             OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)),
         },
-        ErrorKind(kind) => format!("{kind}"),
+        ErrorKind(kind) => format!("{}", kind),
         ParseErrorKind {
             formula,
             message: _,

base/src/expressions/parser/static_analysis.rs

@@ -2,19 +2,15 @@ use crate::functions::Function;
 
 use super::Node;
 
+use once_cell::sync::Lazy;
 use regex::Regex;
-use std::sync::OnceLock;
-
-static RANGE_REFERENCE_REGEX: OnceLock<Regex> = OnceLock::new();
 
 #[allow(clippy::expect_used)]
-fn get_re() -> &'static Regex {
+static RE: Lazy<Regex> =
-    RANGE_REFERENCE_REGEX
+    Lazy::new(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"));
-        .get_or_init(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"))
-}
 
 fn is_range_reference(s: &str) -> bool {
-    get_re().is_match(s)
+    RE.is_match(s)
 }
 
 /*
@@ -341,8 +337,7 @@ fn static_analysis_offset(args: &[Node]) -> StaticResult {
         }
         _ => return StaticResult::Unknown,
     };
-    // Both height and width are explicitly 1, so OFFSET will return a single cell
+    StaticResult::Unknown
-    StaticResult::Scalar
 }
 
 // fn static_analysis_choose(_args: &[Node]) -> StaticResult {
@@ -576,37 +571,6 @@ fn args_signature_xnpv(arg_count: usize) -> Vec<Signature> {
     }
 }
 
-// NETWORKDAYS(start_date, end_date, [holidays])
-// Parameters: start_date (scalar), end_date (scalar), holidays (optional vector)
-fn args_signature_networkdays(arg_count: usize) -> Vec<Signature> {
-    if arg_count == 2 {
-        vec![Signature::Scalar, Signature::Scalar]
-    } else if arg_count == 3 {
-        vec![Signature::Scalar, Signature::Scalar, Signature::Vector]
-    } else {
-        vec![Signature::Error; arg_count]
-    }
-}
-
-// NETWORKDAYS.INTL(start_date, end_date, [weekend], [holidays])
-// Parameters: start_date (scalar), end_date (scalar), weekend (optional scalar), holidays (optional vector)
-fn args_signature_networkdays_intl(arg_count: usize) -> Vec<Signature> {
-    if arg_count == 2 {
-        vec![Signature::Scalar, Signature::Scalar]
-    } else if arg_count == 3 {
-        vec![Signature::Scalar, Signature::Scalar, Signature::Scalar]
-    } else if arg_count == 4 {
-        vec![
-            Signature::Scalar,
-            Signature::Scalar,
-            Signature::Scalar,
-            Signature::Vector,
-        ]
-    } else {
-        vec![Signature::Error; arg_count]
-    }
-}
-
 // FIXME: This is terrible duplications of efforts. We use the signature in at least three different places:
 // 1. When computing the function
 // 2. Checking the arguments to see if we need to insert the implicit intersection operator
@@ -641,9 +605,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Choose => vec![Signature::Scalar; arg_count],
         Function::Column => args_signature_row(arg_count),
         Function::Columns => args_signature_one_vector(arg_count),
-        Function::Ln => args_signature_scalars(arg_count, 1, 0),
-        Function::Log => args_signature_scalars(arg_count, 1, 1),
-        Function::Log10 => args_signature_scalars(arg_count, 1, 0),
         Function::Cos => args_signature_scalars(arg_count, 1, 0),
         Function::Cosh => args_signature_scalars(arg_count, 1, 0),
         Function::Max => vec![Signature::Vector; arg_count],
@@ -722,28 +683,13 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Maxifs => vec![Signature::Vector; arg_count],
         Function::Minifs => vec![Signature::Vector; arg_count],
         Function::Date => args_signature_scalars(arg_count, 3, 0),
-        Function::Datedif => args_signature_scalars(arg_count, 3, 0),
-        Function::Datevalue => args_signature_scalars(arg_count, 1, 0),
         Function::Day => args_signature_scalars(arg_count, 1, 0),
         Function::Edate => args_signature_scalars(arg_count, 2, 0),
         Function::Eomonth => args_signature_scalars(arg_count, 2, 0),
         Function::Month => args_signature_scalars(arg_count, 1, 0),
-        Function::Time => args_signature_scalars(arg_count, 3, 0),
-        Function::Timevalue => args_signature_scalars(arg_count, 1, 0),
-        Function::Hour => args_signature_scalars(arg_count, 1, 0),
-        Function::Minute => args_signature_scalars(arg_count, 1, 0),
-        Function::Second => args_signature_scalars(arg_count, 1, 0),
         Function::Now => args_signature_no_args(arg_count),
         Function::Today => args_signature_no_args(arg_count),
         Function::Year => args_signature_scalars(arg_count, 1, 0),
-        Function::Days => args_signature_scalars(arg_count, 2, 0),
-        Function::Days360 => args_signature_scalars(arg_count, 2, 1),
-        Function::Weekday => args_signature_scalars(arg_count, 1, 1),
-        Function::Weeknum => args_signature_scalars(arg_count, 1, 1),
-        Function::Workday => args_signature_scalars(arg_count, 2, 1),
-        Function::WorkdayIntl => args_signature_scalars(arg_count, 2, 2),
-        Function::Yearfrac => args_signature_scalars(arg_count, 2, 1),
-        Function::Isoweeknum => args_signature_scalars(arg_count, 1, 0),
         Function::Cumipmt => args_signature_scalars(arg_count, 6, 0),
         Function::Cumprinc => args_signature_scalars(arg_count, 6, 0),
         Function::Db => args_signature_scalars(arg_count, 4, 1),
@@ -832,63 +778,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Formulatext => args_signature_scalars(arg_count, 1, 0),
         Function::Unicode => args_signature_scalars(arg_count, 1, 0),
         Function::Geomean => vec![Signature::Vector; arg_count],
-        Function::Networkdays => args_signature_networkdays(arg_count),
-        Function::NetworkdaysIntl => args_signature_networkdays_intl(arg_count),
-        Function::Acot => args_signature_scalars(arg_count, 1, 0),
-        Function::Acoth => args_signature_scalars(arg_count, 1, 0),
-        Function::Cot => args_signature_scalars(arg_count, 1, 0),
-        Function::Coth => args_signature_scalars(arg_count, 1, 0),
-        Function::Csc => args_signature_scalars(arg_count, 1, 0),
-        Function::Csch => args_signature_scalars(arg_count, 1, 0),
-        Function::Sec => args_signature_scalars(arg_count, 1, 0),
-        Function::Sech => args_signature_scalars(arg_count, 1, 0),
-        Function::Exp => args_signature_scalars(arg_count, 1, 0),
-        Function::Fact => args_signature_scalars(arg_count, 1, 0),
-        Function::Factdouble => args_signature_scalars(arg_count, 1, 0),
-        Function::Sign => args_signature_scalars(arg_count, 1, 0),
-        Function::Radians => args_signature_scalars(arg_count, 1, 0),
-        Function::Degrees => args_signature_scalars(arg_count, 1, 0),
-        Function::Int => args_signature_scalars(arg_count, 1, 0),
-        Function::Even => args_signature_scalars(arg_count, 1, 0),
-        Function::Odd => args_signature_scalars(arg_count, 1, 0),
-        Function::Ceiling => args_signature_scalars(arg_count, 2, 0),
-        Function::CeilingMath => args_signature_scalars(arg_count, 1, 2),
-        Function::CeilingPrecise => args_signature_scalars(arg_count, 1, 1),
-        Function::Floor => args_signature_scalars(arg_count, 2, 0),
-        Function::FloorMath => args_signature_scalars(arg_count, 1, 2),
-        Function::FloorPrecise => args_signature_scalars(arg_count, 1, 1),
-        Function::IsoCeiling => args_signature_scalars(arg_count, 1, 1),
-        Function::Mod => args_signature_scalars(arg_count, 2, 0),
-        Function::Quotient => args_signature_scalars(arg_count, 2, 0),
-        Function::Mround => args_signature_scalars(arg_count, 2, 0),
-        Function::Trunc => args_signature_scalars(arg_count, 1, 1),
-        Function::Gcd => vec![Signature::Vector; arg_count],
-        Function::Lcm => vec![Signature::Vector; arg_count],
-        Function::Base => args_signature_scalars(arg_count, 2, 1),
-        Function::Decimal => args_signature_scalars(arg_count, 2, 0),
-        Function::Roman => args_signature_scalars(arg_count, 1, 1),
-        Function::Arabic => args_signature_scalars(arg_count, 1, 0),
-        Function::Combin => args_signature_scalars(arg_count, 2, 0),
-        Function::Combina => args_signature_scalars(arg_count, 2, 0),
-        Function::Sumsq => vec![Signature::Vector; arg_count],
-
-        Function::N => args_signature_scalars(arg_count, 1, 0),
-        Function::Sheets => args_signature_scalars(arg_count, 0, 1),
-        Function::Cell => args_signature_scalars(arg_count, 1, 1),
-        Function::Info => args_signature_scalars(arg_count, 1, 1),
-
-        Function::Daverage => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dcount => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dget => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dmax => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dmin => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dsum => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dcounta => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dproduct => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dstdev => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dvar => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dvarp => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
-        Function::Dstdevp => vec![Signature::Vector, Signature::Scalar, Signature::Vector],
     }
 }
 
@@ -927,9 +816,6 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Round => scalar_arguments(args),
         Function::Rounddown => scalar_arguments(args),
         Function::Roundup => scalar_arguments(args),
-        Function::Ln => scalar_arguments(args),
-        Function::Log => scalar_arguments(args),
-        Function::Log10 => scalar_arguments(args),
         Function::Sin => scalar_arguments(args),
         Function::Sinh => scalar_arguments(args),
         Function::Sqrt => scalar_arguments(args),
@@ -1000,27 +886,12 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Maxifs => not_implemented(args),
         Function::Minifs => not_implemented(args),
         Function::Date => not_implemented(args),
-        Function::Datedif => not_implemented(args),
-        Function::Datevalue => not_implemented(args),
         Function::Day => not_implemented(args),
         Function::Edate => not_implemented(args),
         Function::Month => not_implemented(args),
-        Function::Time => not_implemented(args),
-        Function::Timevalue => not_implemented(args),
-        Function::Hour => not_implemented(args),
-        Function::Minute => not_implemented(args),
-        Function::Second => not_implemented(args),
         Function::Now => not_implemented(args),
         Function::Today => not_implemented(args),
         Function::Year => not_implemented(args),
-        Function::Days => not_implemented(args),
-        Function::Days360 => not_implemented(args),
-        Function::Weekday => not_implemented(args),
-        Function::Weeknum => not_implemented(args),
-        Function::Workday => not_implemented(args),
-        Function::WorkdayIntl => not_implemented(args),
-        Function::Yearfrac => not_implemented(args),
-        Function::Isoweeknum => not_implemented(args),
         Function::Cumipmt => not_implemented(args),
         Function::Cumprinc => not_implemented(args),
         Function::Db => not_implemented(args),
@@ -1109,61 +980,5 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Eomonth => scalar_arguments(args),
         Function::Formulatext => not_implemented(args),
         Function::Geomean => not_implemented(args),
-        Function::Networkdays => not_implemented(args),
-        Function::NetworkdaysIntl => not_implemented(args),
-        Function::Acot => scalar_arguments(args),
-        Function::Acoth => scalar_arguments(args),
-        Function::Cot => scalar_arguments(args),
-        Function::Coth => scalar_arguments(args),
-        Function::Csc => scalar_arguments(args),
-        Function::Csch => scalar_arguments(args),
-        Function::Sec => scalar_arguments(args),
-        Function::Sech => scalar_arguments(args),
-        Function::Exp => scalar_arguments(args),
-        Function::Fact => scalar_arguments(args),
-        Function::Factdouble => scalar_arguments(args),
-        Function::Sign => scalar_arguments(args),
-        Function::Radians => scalar_arguments(args),
-        Function::Degrees => scalar_arguments(args),
-        Function::Int => scalar_arguments(args),
-        Function::Even => scalar_arguments(args),
-        Function::Odd => scalar_arguments(args),
-        Function::Ceiling => scalar_arguments(args),
-        Function::CeilingMath => scalar_arguments(args),
-        Function::CeilingPrecise => scalar_arguments(args),
-        Function::Floor => scalar_arguments(args),
-        Function::FloorMath => scalar_arguments(args),
-        Function::FloorPrecise => scalar_arguments(args),
-        Function::IsoCeiling => scalar_arguments(args),
-        Function::Mod => scalar_arguments(args),
-        Function::Quotient => scalar_arguments(args),
-        Function::Mround => scalar_arguments(args),
-        Function::Trunc => scalar_arguments(args),
-        Function::Gcd => not_implemented(args),
-        Function::Lcm => not_implemented(args),
-        Function::Base => scalar_arguments(args),
-        Function::Decimal => scalar_arguments(args),
-        Function::Roman => scalar_arguments(args),
-        Function::Arabic => scalar_arguments(args),
-        Function::Combin => scalar_arguments(args),
-        Function::Combina => scalar_arguments(args),
-        Function::Sumsq => StaticResult::Scalar,
-        Function::N => scalar_arguments(args),
-        Function::Sheets => scalar_arguments(args),
-        Function::Cell => scalar_arguments(args),
-        Function::Info => scalar_arguments(args),
-
-        Function::Dget => not_implemented(args),
-        Function::Dmax => not_implemented(args),
-        Function::Dmin => not_implemented(args),
-        Function::Dcount => not_implemented(args),
-        Function::Daverage => not_implemented(args),
-        Function::Dsum => not_implemented(args),
-        Function::Dcounta => not_implemented(args),
-        Function::Dproduct => not_implemented(args),
-        Function::Dstdev => not_implemented(args),
-        Function::Dvar => not_implemented(args),
-        Function::Dvarp => not_implemented(args),
-        Function::Dstdevp => not_implemented(args),
     }
 }

base/src/expressions/parser/stringify.rs

@@ -2,7 +2,7 @@ use super::{super::utils::quote_name, Node, Reference};
 use crate::constants::{LAST_COLUMN, LAST_ROW};
 use crate::expressions::parser::move_formula::to_string_array_node;
 use crate::expressions::parser::static_analysis::add_implicit_intersection;
-use crate::expressions::token::{OpSum, OpUnary};
+use crate::expressions::token::OpUnary;
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -28,11 +28,6 @@ pub enum DisplaceData {
         column: i32,
         delta: i32,
     },
-    RowMove {
-        sheet: u32,
-        row: i32,
-        delta: i32,
-    },
     ColumnMove {
         sheet: u32,
         column: i32,
@@ -164,29 +159,6 @@ pub(crate) fn stringify_reference(
                         }
                     }
                 }
-                DisplaceData::RowMove {
-                    sheet,
-                    row: move_row,
-                    delta,
-                } => {
-                    if sheet_index == *sheet {
-                        if row == *move_row {
-                            row += *delta;
-                        } else if *delta > 0 {
-                            // Moving the row downwards
-                            if row > *move_row && row <= *move_row + *delta {
-                                // Intermediate rows move up by one position
-                                row -= 1;
-                            }
-                        } else if *delta < 0 {
-                            // Moving the row upwards
-                            if row < *move_row && row >= *move_row + *delta {
-                                // Intermediate rows move down by one position
-                                row += 1;
-                            }
-                        }
-                    }
-                }
                 DisplaceData::ColumnMove {
                     sheet,
                     column: move_column,
@@ -195,18 +167,14 @@ pub(crate) fn stringify_reference(
                     if sheet_index == *sheet {
                         if column == *move_column {
                             column += *delta;
-                        } else if *delta > 0 {
+                        } else if (*delta > 0
-                            // Moving the column to the right
+                            && column > *move_column
-                            if column > *move_column && column <= *move_column + *delta {
+                            && column <= *move_column + *delta)
-                                // Intermediate columns move left by one position
+                            || (*delta < 0
-                                column -= 1;
+                                && column < *move_column
-                            }
+                                && column >= *move_column + *delta)
-                        } else if *delta < 0 {
+                        {
-                            // Moving the column to the left
+                            column -= *delta;
-                            if column < *move_column && column >= *move_column + *delta {
-                                // Intermediate columns move right by one position
-                                column += 1;
-                            }
                         }
                     }
                 }
@@ -216,16 +184,16 @@ pub(crate) fn stringify_reference(
                 return "#REF!".to_string();
             }
             let mut row_abs = if absolute_row {
-                format!("${row}")
+                format!("${}", row)
             } else {
-                format!("{row}")
+                format!("{}", row)
             };
             let column = match crate::expressions::utils::number_to_column(column) {
                 Some(s) => s,
                 None => return "#REF!".to_string(),
             };
             let mut col_abs = if absolute_column {
-                format!("${column}")
+                format!("${}", column)
             } else {
                 column
             };
@@ -240,27 +208,27 @@ pub(crate) fn stringify_reference(
                     format!("{}!{}{}", quote_name(name), col_abs, row_abs)
                 }
                 None => {
-                    format!("{col_abs}{row_abs}")
+                    format!("{}{}", col_abs, row_abs)
                 }
             }
         }
         None => {
             let row_abs = if absolute_row {
-                format!("R{row}")
+                format!("R{}", row)
             } else {
-                format!("R[{row}]")
+                format!("R[{}]", row)
             };
             let col_abs = if absolute_column {
-                format!("C{column}")
+                format!("C{}", column)
             } else {
-                format!("C[{column}]")
+                format!("C[{}]", column)
             };
             match &sheet_name {
                 Some(name) => {
                     format!("{}!{}{}", quote_name(name), row_abs, col_abs)
                 }
                 None => {
-                    format!("{row_abs}{col_abs}")
+                    format!("{}{}", row_abs, col_abs)
                 }
             }
         }
@@ -288,7 +256,7 @@ fn format_function(
             arguments = stringify(el, context, displace_data, export_to_excel);
         }
     }
-    format!("{name}({arguments})")
+    format!("{}({})", name, arguments)
 }
 
 // There is just one representation in the AST (Abstract Syntax Tree) of a formula.
@@ -324,9 +292,9 @@ fn stringify(
 ) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
+        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
         NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{value}\""),
+        StringKind(value) => format!("\"{}\"", value),
         WrongReferenceKind {
             sheet_name,
             column,
@@ -416,7 +384,7 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         WrongRangeKind {
             sheet_name,
@@ -465,7 +433,7 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{s1}:{s2}")
+            format!("{}:{}", s1, s2)
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
@@ -483,44 +451,45 @@ fn stringify(
             kind,
             stringify(right, context, displace_data, export_to_excel)
         ),
-        OpSumKind { kind, left, right } => {
+        OpSumKind { kind, left, right } => format!(
-            let left_str = stringify(left, context, displace_data, export_to_excel);
+            "{}{}{}",
-            // if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
+            stringify(left, context, displace_data, export_to_excel),
-            let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
+            kind,
-                | matches!(**right, CompareKind { .. })
-            {
-                format!(
-                    "({})",
             stringify(right, context, displace_data, export_to_excel)
-                )
+        ),
-            } else {
-                stringify(right, context, displace_data, export_to_excel)
-            };
-
-            format!("{left_str}{kind}{right_str}")
-        }
         OpProductKind { kind, left, right } => {
             let x = match **left {
-                OpSumKind { .. } | CompareKind { .. } => format!(
+                OpSumKind { .. } => format!(
+                    "({})",
+                    stringify(left, context, displace_data, export_to_excel)
+                ),
+                CompareKind { .. } => format!(
                     "({})",
                     stringify(left, context, displace_data, export_to_excel)
                 ),
                 _ => stringify(left, context, displace_data, export_to_excel),
             };
             let y = match **right {
-                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
+                OpSumKind { .. } => format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                ),
+                CompareKind { .. } => format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                ),
+                OpProductKind { .. } => format!(
                     "({})",
                     stringify(right, context, displace_data, export_to_excel)
                 ),
                 _ => stringify(right, context, displace_data, export_to_excel),
             };
-            format!("{x}{kind}{y}")
+            format!("{}{}{}", x, kind, y)
         }
         OpPowerKind { left, right } => {
             let x = match **left {
                 BooleanKind(_)
                 | NumberKind(_)
-                | UnaryKind { .. }
                 | StringKind(_)
                 | ReferenceKind { .. }
                 | RangeKind { .. }
@@ -536,6 +505,7 @@ fn stringify(
                 | FunctionKind { .. }
                 | InvalidFunctionKind { .. }
                 | ArrayKind(_)
+                | UnaryKind { .. }
                 | ErrorKind(_)
                 | ParseErrorKind { .. }
                 | OpSumKind { .. }
@@ -577,7 +547,7 @@ fn stringify(
                     stringify(right, context, displace_data, export_to_excel)
                 ),
             };
-            format!("{x}^{y}")
+            format!("{}^{}", x, y)
         }
         InvalidFunctionKind { name, args } => {
             format_function(name, args, context, displace_data, export_to_excel)
@@ -612,50 +582,18 @@ fn stringify(
                 }
                 matrix_string.push_str(&row_string);
             }
-            format!("{{{matrix_string}}}")
+            format!("{{{}}}", matrix_string)
         }
         TableNameKind(value) => value.to_string(),
         DefinedNameKind((name, ..)) => name.to_string(),
         WrongVariableKind(name) => name.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
-                let needs_parentheses = match **right {
-                    BooleanKind(_)
-                    | NumberKind(_)
-                    | StringKind(_)
-                    | ReferenceKind { .. }
-                    | RangeKind { .. }
-                    | WrongReferenceKind { .. }
-                    | WrongRangeKind { .. }
-                    | OpRangeKind { .. }
-                    | OpConcatenateKind { .. }
-                    | OpProductKind { .. }
-                    | FunctionKind { .. }
-                    | InvalidFunctionKind { .. }
-                    | ArrayKind(_)
-                    | DefinedNameKind(_)
-                    | TableNameKind(_)
-                    | WrongVariableKind(_)
-                    | ImplicitIntersection { .. }
-                    | CompareKind { .. }
-                    | ErrorKind(_)
-                    | ParseErrorKind { .. }
-                    | EmptyArgKind => false,
-
-                    OpPowerKind { .. } | OpSumKind { .. } | UnaryKind { .. } => true,
-                };
-                if needs_parentheses {
-                    format!(
-                        "-({})",
-                        stringify(right, context, displace_data, export_to_excel)
-                    )
-                } else {
                 format!(
                     "-{}",
                     stringify(right, context, displace_data, export_to_excel)
                 )
             }
-            }
             OpUnary::Percentage => {
                 format!(
                     "{}%",
@@ -663,7 +601,7 @@ fn stringify(
                 )
             }
         },
-        ErrorKind(kind) => format!("{kind}"),
+        ErrorKind(kind) => format!("{}", kind),
         ParseErrorKind {
             formula,
             position: _,

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

@@ -3,7 +3,6 @@ mod test_arrays;
 mod test_general;
 mod test_implicit_intersection;
 mod test_issue_155;
-mod test_issue_483;
 mod test_move_formula;
 mod test_ranges;
 mod test_stringify;

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

@@ -1,27 +0,0 @@
-#![allow(clippy::panic)]
-
-use std::collections::HashMap;
-
-use crate::expressions::parser::stringify::to_string;
-use crate::expressions::parser::{Node, Parser};
-use crate::expressions::types::CellReferenceRC;
-
-#[test]
-fn issue_483_parser() {
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    // Reference cell is Sheet1!A1
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 2,
-        column: 2,
-    };
-    let t = parser.parse("-(A1^1.22)", &cell_reference);
-    assert!(matches!(t, Node::UnaryKind { .. }));
-    assert_eq!(to_string(&t, &cell_reference), "-(A1^1.22)");
-
-    let t = parser.parse("-A1^1.22", &cell_reference);
-    assert!(matches!(t, Node::OpPowerKind { .. }));
-    assert_eq!(to_string(&t, &cell_reference), "-A1^1.22");
-}

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

@@ -32,39 +32,3 @@ fn exp_order() {
     let t = parser.parse("(5)^(4)", &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "5^4");
 }
-
-#[test]
-fn correct_parenthesis() {
-    let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
-
-    let cell_reference = CellReferenceRC {
-        sheet: "Sheet1".to_string(),
-        row: 1,
-        column: 1,
-    };
-
-    let t = parser.parse("-(1 + 1)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
-
-    let t = parser.parse("1 - (3 + 4)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
-
-    let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
-    assert_eq!(
-        to_string(&t, &cell_reference),
-        "-(1.05*(0.0284+0.0046)-0.0284)"
-    );
-
-    let t = parser.parse("1 + (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1+3+5");
-
-    let t = parser.parse("1 - (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
-
-    let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
-
-    let t = parser.parse("1 + (3<5)", &cell_reference);
-    assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
-}

base/src/expressions/utils/mod.rs

@@ -211,19 +211,15 @@ pub fn parse_reference_a1(r: &str) -> Option<ParsedReference> {
 pub fn is_valid_identifier(name: &str) -> bool {
     // https://support.microsoft.com/en-us/office/names-in-formulas-fc2935f9-115d-4bef-a370-3aa8bb4c91f1
     // https://github.com/MartinTrummer/excel-names/
+    // NOTE: We are being much more restrictive than Excel.
+    // In particular we do not support non ascii characters.
     let upper = name.to_ascii_uppercase();
-    // length of chars
+    let bytes = upper.as_bytes();
-    let len = upper.chars().count();
+    let len = bytes.len();
-
-    let mut chars = upper.chars();
-
     if len > 255 || len == 0 {
         return false;
     }
-    let first = match chars.next() {
+    let first = bytes[0] as char;
-        Some(ch) => ch,
-        None => return false,
-    };
     // The first character of a name must be a letter, an underscore character (_), or a backslash (\).
     if !(first.is_ascii_alphabetic() || first == '_' || first == '\\') {
         return false;
@@ -241,11 +237,21 @@ pub fn is_valid_identifier(name: &str) -> bool {
     if parse_reference_r1c1(name).is_some() {
         return false;
     }
-    for ch in chars {
+    let mut i = 1;
-        if !(ch.is_alphanumeric() || ch == '_' || ch == '.') {
+    while i < len {
+        let ch = bytes[i] as char;
+        match ch {
+            'a'..='z' => {}
+            'A'..='Z' => {}
+            '0'..='9' => {}
+            '_' => {}
+            '.' => {}
+            _ => {
                 return false;
             }
         }
+        i += 1;
+    }
 
     true
 }
@@ -253,23 +259,15 @@ pub fn is_valid_identifier(name: &str) -> bool {
 fn name_needs_quoting(name: &str) -> bool {
     let chars = name.chars();
     // it contains any of these characters: ()'$,;-+{} or space
-    for (i, char) in chars.enumerate() {
+    for char in chars {
         if [' ', '(', ')', '\'', '$', ',', ';', '-', '+', '{', '}'].contains(&char) {
             return true;
         }
-        // if it starts with a number
-        if i == 0 && char.is_ascii_digit() {
-            return true;
     }
-    }
+    // TODO:
-    if parse_reference_a1(name).is_some() {
     // cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
-        return true;
-    }
-    if parse_reference_r1c1(name).is_some() {
     // cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
-        return true;
+    // integers
-    }
     false
 }
 
@@ -281,32 +279,3 @@ pub fn quote_name(name: &str) -> String {
     };
     name.to_string()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_quote_name() {
-        assert_eq!(quote_name("Sheet1"), "Sheet1");
-        assert_eq!(quote_name("Sheet 1"), "'Sheet 1'");
-        // escape and quote
-        assert_eq!(quote_name("Sheet1'"), "'Sheet1'''");
-        assert_eq!(quote_name("Data(2024)"), "'Data(2024)'");
-        assert_eq!(quote_name("Data$2024"), "'Data$2024'");
-        assert_eq!(quote_name("Data-2024"), "'Data-2024'");
-        assert_eq!(quote_name("Data+2024"), "'Data+2024'");
-        assert_eq!(quote_name("Data,2024"), "'Data,2024'");
-        assert_eq!(quote_name("Data;2024"), "'Data;2024'");
-        assert_eq!(quote_name("Data{2024}"), "'Data{2024}'");
-
-        assert_eq!(quote_name("2024"), "'2024'");
-        assert_eq!(quote_name("1Data"), "'1Data'");
-        assert_eq!(quote_name("A1"), "'A1'");
-        assert_eq!(quote_name("R1C1"), "'R1C1'");
-        assert_eq!(quote_name("MySheet"), "MySheet");
-
-        assert_eq!(quote_name("B1048576"), "'B1048576'");
-        assert_eq!(quote_name("B1048577"), "B1048577");
-    }
-}

base/src/expressions/utils/test.rs

@@ -196,7 +196,6 @@ fn test_names() {
     assert!(is_valid_identifier("_."));
     assert!(is_valid_identifier("_1"));
     assert!(is_valid_identifier("\\."));
-    assert!(is_valid_identifier("truñe"));
 
     // invalid
     assert!(!is_valid_identifier("true"));
@@ -210,7 +209,6 @@ fn test_names() {
     assert!(!is_valid_identifier("1true"));
 
     assert!(!is_valid_identifier("test€"));
+    assert!(!is_valid_identifier("truñe"));
     assert!(!is_valid_identifier("tr&ue"));
-
-    assert!(!is_valid_identifier("LOG10"));
 }

base/src/formatter/dates.rs

@@ -8,8 +8,6 @@ use crate::constants::EXCEL_DATE_BASE;
 use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
 use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 
-pub const DATE_OUT_OF_RANGE_MESSAGE: &str = "Out of range parameters for date";
-
 #[inline]
 fn convert_to_serial_number(date: NaiveDate) -> i32 {
     date.num_days_from_ce() - EXCEL_DATE_BASE
@@ -23,12 +21,14 @@ fn is_date_within_range(date: NaiveDate) -> bool {
 pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
     if days < MINIMUM_DATE_SERIAL_NUMBER as i64 {
         return Err(format!(
-            "Excel date must be greater than {MINIMUM_DATE_SERIAL_NUMBER}"
+            "Excel date must be greater than {}",
+            MINIMUM_DATE_SERIAL_NUMBER
         ));
     };
     if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
         return Err(format!(
-            "Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}"
+            "Excel date must be less than {}",
+            MAXIMUM_DATE_SERIAL_NUMBER
         ));
     };
     #[allow(clippy::expect_used)]
@@ -39,7 +39,7 @@ pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
 pub fn date_to_serial_number(day: u32, month: u32, year: i32) -> Result<i32, String> {
     match NaiveDate::from_ymd_opt(year, month, day) {
         Some(native_date) => Ok(convert_to_serial_number(native_date)),
-        None => Err(DATE_OUT_OF_RANGE_MESSAGE.to_string()),
+        None => Err("Out of range parameters for date".to_string()),
     }
 }
 
@@ -57,7 +57,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
         return Ok(MINIMUM_DATE_SERIAL_NUMBER);
     }
     let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
-        return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
+        return Err("Out of range parameters for date".to_string());
     };
 
     // One thing to note for example is that even if you started with a year out of range
@@ -70,7 +70,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
     // As a result, we have to run range checks as we parse the date from the biggest unit to the
     // smallest unit.
     if !is_date_within_range(date) {
-        return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
+        return Err("Out of range parameters for date".to_string());
     }
 
     date = {
@@ -82,7 +82,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
             date = date + Months::new(abs_month);
         }
         if !is_date_within_range(date) {
-            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
+            return Err("Out of range parameters for date".to_string());
         }
         date
     };
@@ -96,7 +96,7 @@ pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Resu
             date = date + Days::new(abs_day);
         }
         if !is_date_within_range(date) {
-            return Err(DATE_OUT_OF_RANGE_MESSAGE.to_string());
+            return Err("Out of range parameters for date".to_string());
         }
         date
     };

base/src/formatter/format.rs

@@ -15,7 +15,7 @@ pub struct Formatted {
 
 /// Returns the vector of chars of the fractional part of a *positive* number:
 /// 3.1415926 ==> ['1', '4', '1', '5', '9', '2', '6']
-fn get_fract_part(value: f64, precision: i32, int_len: usize) -> Vec<char> {
+fn get_fract_part(value: f64, precision: i32) -> Vec<char> {
     let b = format!("{:.1$}", value.fract(), precision as usize)
         .chars()
         .collect::<Vec<char>>();
@@ -30,12 +30,6 @@ fn get_fract_part(value: f64, precision: i32, int_len: usize) -> Vec<char> {
     if last_non_zero < 2 {
         return vec![];
     }
-    let max_len = if int_len > 15 {
-        2_usize
-    } else {
-        15_usize - int_len + 1
-    };
-    let last_non_zero = usize::min(last_non_zero, max_len + 1);
     b[2..last_non_zero].to_vec()
 }
 
@@ -126,7 +120,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             // We should have different codepaths for general formatting and errors
             let value_abs = value.abs();
             if (1.0e-8..1.0e+11).contains(&value_abs) {
-                let mut text = format!("{value:.9}");
+                let mut text = format!("{:.9}", value);
                 text = text.trim_end_matches('0').trim_end_matches('.').to_string();
                 Formatted {
                     text,
@@ -144,7 +138,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                 let exponent = value_abs.log10().floor();
                 value /= 10.0_f64.powf(exponent);
                 let sign = if exponent < 0.0 { '-' } else { '+' };
-                let s = format!("{value:.5}");
+                let s = format!("{:.5}", value);
                 Formatted {
                     text: format!(
                         "{}E{}{:02}",
@@ -160,72 +154,48 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         ParsePart::Date(p) => {
             let tokens = &p.tokens;
             let mut text = "".to_string();
-            let time_fract = value.fract();
+            let date = match from_excel_date(value as i64) {
-            let hours = (time_fract * 24.0).floor();
+                Ok(d) => d,
-            let minutes = ((time_fract * 24.0 - hours) * 60.0).floor();
+                Err(e) => {
-            let seconds = ((((time_fract * 24.0 - hours) * 60.0) - minutes) * 60.0).round();
+                    return Formatted {
-            let date = from_excel_date(value as i64).ok();
+                        text: "#VALUE!".to_owned(),
+                        color: None,
+                        error: Some(e),
+                    }
+                }
+            };
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
-                        text = format!("{text}{c}");
+                        text = format!("{}{}", text, c);
                     }
                     TextToken::Text(t) => {
-                        text = format!("{text}{t}");
+                        text = format!("{}{}", text, t);
                     }
                     TextToken::Ghost(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                     }
                     TextToken::Spacer(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                     }
                     TextToken::Raw => {
-                        text = format!("{text}{value}");
+                        text = format!("{}{}", text, value);
                     }
                     TextToken::Digit(_) => {}
                     TextToken::Period => {}
-                    TextToken::Day => match date {
+                    TextToken::Day => {
-                        Some(date) => {
                         let day = date.day() as usize;
-                            text = format!("{text}{day}");
+                        text = format!("{}{}", text, day);
                     }
-                        None => {
-                            return Formatted {
-                                text: "#VALUE!".to_owned(),
-                                color: None,
-                                error: Some(format!("Invalid date value: '{value}'")),
-                            }
-                        }
-                    },
                     TextToken::DayPadded => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let day = date.day() as usize;
-                        text = format!("{text}{day:02}");
+                        text = format!("{}{:02}", text, day);
                     }
                     TextToken::DayNameShort => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let mut day = date.weekday().number_from_monday() as usize;
                         if day == 7 {
                             day = 0;
@@ -233,16 +203,6 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                         text = format!("{}{}", text, &locale.dates.day_names_short[day]);
                     }
                     TextToken::DayName => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let mut day = date.weekday().number_from_monday() as usize;
                         if day == 7 {
                             day = 0;
@@ -250,144 +210,32 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                         text = format!("{}{}", text, &locale.dates.day_names[day]);
                     }
                     TextToken::Month => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let month = date.month() as usize;
-                        text = format!("{text}{month}");
+                        text = format!("{}{}", text, month);
                     }
                     TextToken::MonthPadded => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let month = date.month() as usize;
-                        text = format!("{text}{month:02}");
+                        text = format!("{}{:02}", text, month);
                     }
                     TextToken::MonthNameShort => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let month = date.month() as usize;
                         text = format!("{}{}", text, &locale.dates.months_short[month - 1]);
                     }
                     TextToken::MonthName => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let month = date.month() as usize;
                         text = format!("{}{}", text, &locale.dates.months[month - 1]);
                     }
                     TextToken::MonthLetter => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         let month = date.month() as usize;
                         let months_letter = &locale.dates.months_letter[month - 1];
-                        text = format!("{text}{months_letter}");
+                        text = format!("{}{}", text, months_letter);
                     }
                     TextToken::YearShort => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         text = format!("{}{}", text, date.format("%y"));
                     }
                     TextToken::Year => {
-                        let date = match date {
-                            Some(d) => d,
-                            None => {
-                                return Formatted {
-                                    text: "#VALUE!".to_owned(),
-                                    color: None,
-                                    error: Some(format!("Invalid date value: '{value}'")),
-                                }
-                            }
-                        };
                         text = format!("{}{}", text, date.year());
                     }
-                    TextToken::Hour => {
-                        let mut hour = hours as i32;
-                        if p.use_ampm {
-                            if hour == 0 {
-                                hour = 12;
-                            } else if hour > 12 {
-                                hour -= 12;
-                            }
-                        }
-                        text = format!("{text}{hour}");
-                    }
-                    TextToken::HourPadded => {
-                        let mut hour = hours as i32;
-                        if p.use_ampm {
-                            if hour == 0 {
-                                hour = 12;
-                            } else if hour > 12 {
-                                hour -= 12;
-                            }
-                        }
-                        text = format!("{text}{hour:02}");
-                    }
-                    TextToken::Second => {
-                        let second = seconds as i32;
-                        text = format!("{text}{second}");
-                    }
-                    TextToken::SecondPadded => {
-                        let second = seconds as i32;
-                        text = format!("{text}{second:02}");
-                    }
-                    TextToken::AMPM => {
-                        let ampm = if hours < 12.0 { "AM" } else { "PM" };
-                        text = format!("{text}{ampm}");
-                    }
-                    TextToken::Minute => {
-                        let minute = minutes as i32;
-                        text = format!("{text}{minute}");
-                    }
-                    TextToken::MinutePadded => {
-                        let minute = minutes as i32;
-                        text = format!("{text}{minute:02}");
-                    }
                 }
             }
             Formatted {
@@ -399,7 +247,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         ParsePart::Number(p) => {
             let mut text = "".to_string();
             if let Some(c) = p.currency {
-                text = format!("{c}");
+                text = format!("{}", c);
             }
             let tokens = &p.tokens;
             value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
@@ -429,7 +277,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             if value_abs as i64 == 0 {
                 int_part = vec![];
             }
-            let fract_part = get_fract_part(value_abs, p.precision, int_part.len());
+            let fract_part = get_fract_part(value_abs, p.precision);
             // ln is the number of digits of the integer part of the value
             let ln = int_part.len() as i32;
             // digit count is the number of digit tokens ('0', '?' and '#') to the left of the decimal point
@@ -447,26 +295,26 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
-                        text = format!("{text}{c}");
+                        text = format!("{}{}", text, c);
                     }
                     TextToken::Text(t) => {
-                        text = format!("{text}{t}");
+                        text = format!("{}{}", text, t);
                     }
                     TextToken::Ghost(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                     }
                     TextToken::Spacer(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{text} ");
+                        text = format!("{} ", text);
                     }
                     TextToken::Raw => {
-                        text = format!("{text}{value}");
+                        text = format!("{}{}", text, value);
                     }
                     TextToken::Period => {
-                        text = format!("{text}{decimal_separator}");
+                        text = format!("{}{}", text, decimal_separator);
                     }
                     TextToken::Digit(digit) => {
                         if digit.number == 'i' {
@@ -474,7 +322,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             let index = digit.index;
                             let number_index = ln - digit_count + index;
                             if index == 0 && is_negative {
-                                text = format!("-{text}");
+                                text = format!("-{}", text);
                             }
                             if ln <= digit_count {
                                 // The number of digits is less or equal than the number of digit tokens
@@ -499,7 +347,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                     } else {
                                         ""
                                     };
-                                    text = format!("{text}{c}{sep}");
+                                    text = format!("{}{}{}", text, c, sep);
                                 }
                                 digit_index += 1;
                             } else {
@@ -525,18 +373,18 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             if index < fract_part.len() {
                                 text = format!("{}{}", text, fract_part[index]);
                             } else if digit.kind == '0' {
-                                text = format!("{text}0");
+                                text = format!("{}0", text);
                             } else if digit.kind == '?' {
-                                text = format!("{text} ");
+                                text = format!("{} ", text);
                             }
                         } else if digit.number == 'e' {
                             // 3. Exponent part
                             let index = digit.index;
                             if index == 0 {
                                 if exponent_is_negative {
-                                    text = format!("{text}E-");
+                                    text = format!("{}E-", text);
                                 } else {
-                                    text = format!("{text}E+");
+                                    text = format!("{}E+", text);
                                 }
                             }
                             let number_index = l_exp - (p.exponent_digit_count - index);
@@ -552,7 +400,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                         exponent_part[number_index as usize]
                                     };
 
-                                    text = format!("{text}{c}");
+                                    text = format!("{}{}", text, c);
                                 }
                             } else {
                                 for i in 0..number_index + 1 {
@@ -574,13 +422,6 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     TextToken::MonthLetter => {}
                     TextToken::YearShort => {}
                     TextToken::Year => {}
-                    TextToken::Hour => {}
-                    TextToken::HourPadded => {}
-                    TextToken::Minute => {}
-                    TextToken::MinutePadded => {}
-                    TextToken::Second => {}
-                    TextToken::SecondPadded => {}
-                    TextToken::AMPM => {}
                 }
             }
             Formatted {
@@ -750,10 +591,10 @@ fn parse_date(value: &str) -> Result<(i32, String), String> {
 /// "30.34%" => (0.3034, "0.00%")
 /// 100€ => (100, "100€")
 pub(crate) fn parse_formatted_number(
-    original: &str,
+    value: &str,
     currencies: &[&str],
 ) -> Result<(f64, Option<String>), String> {
-    let value = original.trim();
+    let value = value.trim();
     let scientific_format = "0.00E+00";
 
     // Check if it is a percentage
@@ -773,7 +614,7 @@ pub(crate) fn parse_formatted_number(
 
     // check if it is a currency in currencies
     for currency in currencies {
-        if let Some(p) = value.strip_prefix(&format!("-{currency}")) {
+        if let Some(p) = value.strip_prefix(&format!("-{}", currency)) {
             let (f, options) = parse_number(p.trim())?;
             if options.is_scientific {
                 return Ok((f, Some(scientific_format.to_string())));
@@ -805,8 +646,7 @@ pub(crate) fn parse_formatted_number(
         }
     }
 
-    // check if it is a date. NOTE: we don't trim the original here
+    if let Ok((serial_number, format)) = parse_date(value) {
-    if let Ok((serial_number, format)) = parse_date(original) {
         return Ok((serial_number as f64, Some(format)));
     }
 

base/src/formatter/lexer.rs

@@ -26,23 +26,19 @@ pub enum Token {
     Scientific,    // E+
     ScientificMinus, // E-
     General,       // General
-    // Dates and time
+    // Dates
     Day,            // d
     DayPadded,      // dd
     DayNameShort,   // ddd
     DayName,        // dddd+
-    Month,          // m (or minute)
+    Month,          // m
-    MonthPadded,    // mm (or minute padded)
+    MonthPadded,    // mm
     MonthNameShort, // mmm
     MonthName,      // mmmm or mmmmmm+
     MonthLetter,    // mmmmm
     YearShort,      // y or yy
     Year,           // yyy+
-    Hour,           // h
+    // TODO: Hours Minutes and Seconds
-    HourPadded,     // hh
-    Second,         // s
-    SecondPadded,   // ss
-    AMPM,           // AM/PM (or A/P)
     ILLEGAL,
     EOF,
 }
@@ -337,7 +333,7 @@ impl Lexer {
                         } else if s == '-' {
                             Token::ScientificMinus
                         } else {
-                            self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
+                            self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
                             Token::ILLEGAL
                         }
                     } else {
@@ -365,8 +361,8 @@ impl Lexer {
                         self.read_next_char();
                     }
                     match m {
-                        1 => Token::Month,       // (or minute)
+                        1 => Token::Month,
-                        2 => Token::MonthPadded, // (or minute padded)
+                        2 => Token::MonthPadded,
                         3 => Token::MonthNameShort,
                         4 => Token::MonthName,
                         5 => Token::MonthLetter,
@@ -385,75 +381,18 @@ impl Lexer {
                         Token::Year
                     }
                 }
-                'h' => {
-                    let mut h = 1;
-                    while let Some('h') = self.peek_char() {
-                        h += 1;
-                        self.read_next_char();
-                    }
-                    if h == 1 {
-                        Token::Hour
-                    } else if h == 2 {
-                        Token::HourPadded
-                    } else {
-                        self.set_error("Unexpected character after 'h'");
-                        Token::ILLEGAL
-                    }
-                }
-                's' => {
-                    let mut s = 1;
-                    while let Some('s') = self.peek_char() {
-                        s += 1;
-                        self.read_next_char();
-                    }
-                    if s == 1 {
-                        Token::Second
-                    } else if s == 2 {
-                        Token::SecondPadded
-                    } else {
-                        self.set_error("Unexpected character after 's'");
-                        Token::ILLEGAL
-                    }
-                }
-                'A' | 'a' => {
-                    if let Some('M') | Some('m') = self.peek_char() {
-                        self.read_next_char();
-                    } else {
-                        self.set_error("Unexpected character after 'A'");
-                        return Token::ILLEGAL;
-                    }
-                    if let Some('/') = self.peek_char() {
-                        self.read_next_char();
-                    } else {
-                        self.set_error("Unexpected character after 'AM'");
-                        return Token::ILLEGAL;
-                    }
-                    if let Some('P') | Some('p') = self.peek_char() {
-                        self.read_next_char();
-                    } else {
-                        self.set_error("Unexpected character after 'AM'");
-                        return Token::ILLEGAL;
-                    }
-                    if let Some('M') | Some('m') = self.peek_char() {
-                        self.read_next_char();
-                    } else {
-                        self.set_error("Unexpected character after 'AMP'");
-                        return Token::ILLEGAL;
-                    }
-                    Token::AMPM
-                }
                 'g' | 'G' => {
                     for c in "eneral".chars() {
                         let cc = self.read_next_char();
                         if Some(c) != cc {
-                            self.set_error(&format!("Unexpected character: {x}"));
+                            self.set_error(&format!("Unexpected character: {}", x));
                             return Token::ILLEGAL;
                         }
                     }
                     Token::General
                 }
                 _ => {
-                    self.set_error(&format!("Unexpected character: {x}"));
+                    self.set_error(&format!("Unexpected character: {}", x));
                     Token::ILLEGAL
                 }
             },

base/src/formatter/parser.rs

@@ -27,13 +27,6 @@ pub enum TextToken {
     MonthLetter,
     YearShort,
     Year,
-    Hour,
-    HourPadded,
-    Minute,
-    MinutePadded,
-    Second,
-    SecondPadded,
-    AMPM,
 }
 pub struct NumberPart {
     pub color: Option<i32>,
@@ -52,7 +45,6 @@ pub struct NumberPart {
 
 pub struct DatePart {
     pub color: Option<i32>,
-    pub use_ampm: bool,
     pub tokens: Vec<TextToken>,
 }
 
@@ -109,7 +101,6 @@ impl Parser {
         let mut digit_count = 0;
         let mut precision = 0;
         let mut is_date = false;
-        let mut use_ampm = false;
         let mut is_number = false;
         let mut found_decimal_dot = false;
         let mut use_thousands = false;
@@ -125,7 +116,6 @@ impl Parser {
         let mut number = 'i';
         let mut index = 0;
         let mut currency = None;
-        let mut is_time = false;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -210,9 +200,6 @@ impl Parser {
                     index += 1;
                 }
                 Token::Literal(value) => {
-                    if value == ':' {
-                        is_time = true;
-                    }
                     tokens.push(TextToken::Literal(value));
                 }
                 Token::Text(value) => {
@@ -249,23 +236,13 @@ impl Parser {
                     tokens.push(TextToken::MonthName);
                 }
                 Token::Month => {
-                    if is_time {
-                        // minute
-                        tokens.push(TextToken::Minute);
-                    } else {
                     is_date = true;
                     tokens.push(TextToken::Month);
                 }
-                }
                 Token::MonthPadded => {
-                    if is_time {
-                        // minute padded
-                        tokens.push(TextToken::MinutePadded);
-                    } else {
                     is_date = true;
                     tokens.push(TextToken::MonthPadded);
                 }
-                }
                 Token::MonthLetter => {
                     is_date = true;
                     tokens.push(TextToken::MonthLetter);
@@ -278,32 +255,6 @@ impl Parser {
                     is_date = true;
                     tokens.push(TextToken::Year);
                 }
-                Token::Hour => {
-                    is_date = true;
-                    is_time = true;
-                    tokens.push(TextToken::Hour);
-                }
-                Token::HourPadded => {
-                    is_date = true;
-                    is_time = true;
-                    tokens.push(TextToken::HourPadded);
-                }
-                Token::Second => {
-                    is_date = true;
-                    is_time = true;
-                    tokens.push(TextToken::Second);
-                }
-                Token::SecondPadded => {
-                    is_date = true;
-                    is_time = true;
-                    tokens.push(TextToken::SecondPadded);
-                }
-
-                Token::AMPM => {
-                    is_date = true;
-                    use_ampm = true;
-                    tokens.push(TextToken::AMPM);
-                }
                 Token::Scientific => {
                     if !is_scientific {
                         index = 0;
@@ -331,11 +282,7 @@ impl Parser {
             if is_number {
                 return ParsePart::Error(ErrorPart {});
             }
-            ParsePart::Date(DatePart {
+            ParsePart::Date(DatePart { color, tokens })
-                color,
-                use_ampm,
-                tokens,
-            })
         } else {
             ParsePart::Number(NumberPart {
                 color,

base/src/formatter/test/mod.rs

@@ -1,3 +1,2 @@
 mod test_general;
 mod test_parse_formatted_number;
-mod test_time;

base/src/formatter/test/test_time.rs

@@ -1,32 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{
-    formatter::format::format_number,
-    locale::{get_locale, Locale},
-};
-
-fn get_default_locale() -> &'static Locale {
-    get_locale("en").unwrap()
-}
-
-#[test]
-fn simple_test() {
-    let locale = get_default_locale();
-    let format = "h:mm AM/PM";
-    let value = 16.001_423_611_111_11; // =1/86400 => 12:02 AM
-    let formatted = format_number(value, format, locale);
-    assert_eq!(formatted.text, "12:02 AM");
-}
-
-#[test]
-fn padded_vs_unpadded() {
-    let locale = get_default_locale();
-    let padded_format = "hh:mm:ss AM/PM";
-    let unpadded_format = "h:m:s AM/PM";
-    let value = 0.25351851851851853; // => 6:05:04 AM (21904/(24*60*60)) where 21904 = 6 * 3600 + 5*60 + 4
-    let formatted = format_number(value, padded_format, locale);
-    assert_eq!(formatted.text, "06:05:04 AM");
-
-    let formatted = format_number(value, unpadded_format, locale);
-    assert_eq!(formatted.text, "6:5:4 AM");
-}

base/src/functions/database.rs

@@ -1,946 +0,0 @@
-use chrono::Datelike;
-
-use crate::{
-    calc_result::CalcResult,
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
-    formatter::dates::date_to_serial_number,
-    Model,
-};
-
-use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex};
-
-impl Model {
-    // =DAVERAGE(database, field, criteria)
-    pub(crate) fn fn_daverage(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut sum = 0.0f64;
-        let mut count = 0usize;
-
-        let mut row = db_left.row + 1; // skip header
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if let CalcResult::Number(n) = v {
-                    if n.is_finite() {
-                        sum += n;
-                        count += 1;
-                    }
-                }
-            }
-            row += 1;
-        }
-
-        if count == 0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "No numeric values matched criteria".to_string(),
-            };
-        }
-
-        CalcResult::Number(sum / count as f64)
-    }
-
-    // =DCOUNT(database, field, criteria)
-    // Counts numeric entries in the field for rows that match criteria
-    pub(crate) fn fn_dcount(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut count = 0usize;
-        let mut row = db_left.row + 1; // skip header
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if matches!(v, CalcResult::Number(_)) {
-                    count += 1;
-                }
-            }
-            row += 1;
-        }
-
-        CalcResult::Number(count as f64)
-    }
-
-    // =DGET(database, field, criteria)
-    // Returns the (single) field value for the unique matching row
-    pub(crate) fn fn_dget(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut result: Option<CalcResult> = None;
-        let mut matches = 0usize;
-
-        let mut row = db_left.row + 1;
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                matches += 1;
-                if matches > 1 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "More than one matching record".to_string(),
-                    };
-                }
-                result = Some(self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                }));
-            }
-            row += 1;
-        }
-
-        match (matches, result) {
-            (0, _) | (_, None) => CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No matching record".to_string(),
-            },
-            (_, Some(v)) => v,
-        }
-    }
-
-    // =DMAX(database, field, criteria)
-    pub(crate) fn fn_dmax(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        self.db_extreme(args, cell, true)
-    }
-
-    // =DMIN(database, field, criteria)
-    pub(crate) fn fn_dmin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        self.db_extreme(args, cell, false)
-    }
-
-    // =DSUM(database, field, criteria)
-    pub(crate) fn fn_dsum(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut sum = 0.0;
-
-        // skip header
-        let mut row = db_left.row + 1;
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if let CalcResult::Number(n) = v {
-                    if n.is_finite() {
-                        sum += n;
-                    }
-                }
-            }
-            row += 1;
-        }
-
-        CalcResult::Number(sum)
-    }
-
-    // =DCOUNTA(database, field, criteria)
-    // Counts non-empty entries (any type) in the field for rows that match criteria
-    pub(crate) fn fn_dcounta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut count = 0;
-        for row in (db_left.row + 1)..=db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if !matches!(v, CalcResult::EmptyCell | CalcResult::EmptyArg) {
-                    count += 1;
-                }
-            }
-        }
-
-        CalcResult::Number(count as f64)
-    }
-
-    // =DPRODUCT(database, field, criteria)
-    pub(crate) fn fn_dproduct(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut product = 1.0f64;
-        let mut has_numeric = false;
-
-        let mut row = db_left.row + 1; // skip header
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if let CalcResult::Number(n) = v {
-                    if n.is_finite() {
-                        product *= n;
-                        has_numeric = true;
-                    }
-                }
-            }
-            row += 1;
-        }
-
-        // Excel returns 0 when no rows / no numeric values match for DPRODUCT
-        if has_numeric {
-            CalcResult::Number(product)
-        } else {
-            CalcResult::Number(0.0)
-        }
-    }
-
-    // Small internal helper for DSTDEV / DVAR
-    // Collects sum, sum of squares, and count of numeric values in the field
-    // for rows that match the criteria.
-    fn db_numeric_stats(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-    ) -> Result<(f64, f64, usize), CalcResult> {
-        if args.len() != 3 {
-            return Err(CalcResult::new_args_number_error(cell));
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return Err(e),
-        };
-
-        let field_col = self.resolve_db_field_column(db_left, db_right, &args[1], cell)?;
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return Err(e),
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return Err(CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            });
-        }
-
-        let mut sum = 0.0f64;
-        let mut sumsq = 0.0f64;
-        let mut count = 0usize;
-
-        let mut row = db_left.row + 1; // skip header
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if let CalcResult::Number(n) = v {
-                    if n.is_finite() {
-                        sum += n;
-                        sumsq += n * n;
-                        count += 1;
-                    }
-                }
-            }
-            row += 1;
-        }
-
-        Ok((sum, sumsq, count))
-    }
-
-    // =DSTDEV(database, field, criteria)
-    // Sample standard deviation of matching numeric values
-    pub(crate) fn fn_dstdev(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
-            Ok(stats) => stats,
-            Err(e) => return e,
-        };
-
-        // Excel behaviour: #DIV/0! if 0 or 1 numeric values match
-        if count < 2 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Not enough numeric values matched criteria".to_string(),
-            };
-        }
-
-        let n = count as f64;
-        let var = (sumsq - (sum * sum) / n) / (n - 1.0);
-        let var = if var < 0.0 { 0.0 } else { var };
-        CalcResult::Number(var.sqrt())
-    }
-
-    // =DVAR(database, field, criteria)
-    // Sample variance of matching numeric values
-    pub(crate) fn fn_dvar(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
-            Ok(stats) => stats,
-            Err(e) => return e,
-        };
-
-        // Excel behaviour: #DIV/0! if 0 or 1 numeric values match
-        if count < 2 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "Not enough numeric values matched criteria".to_string(),
-            };
-        }
-
-        let n = count as f64;
-        let var = (sumsq - (sum * sum) / n) / (n - 1.0);
-        let var = if var < 0.0 { 0.0 } else { var };
-        CalcResult::Number(var)
-    }
-
-    // =DSTDEVP(database, field, criteria)
-    // Population standard deviation of matching numeric values
-    pub(crate) fn fn_dstdevp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
-            Ok(stats) => stats,
-            Err(e) => return e,
-        };
-
-        // Excel behaviour: #DIV/0! if no numeric values match
-        if count == 0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "No numeric values matched criteria".to_string(),
-            };
-        }
-
-        let n = count as f64;
-        let var = (sumsq - (sum * sum) / n) / n;
-        let var = if var < 0.0 { 0.0 } else { var };
-        CalcResult::Number(var.sqrt())
-    }
-
-    // =DVARP(database, field, criteria)
-    // Population variance of matching numeric values
-    pub(crate) fn fn_dvarp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let (sum, sumsq, count) = match self.db_numeric_stats(args, cell) {
-            Ok(stats) => stats,
-            Err(e) => return e,
-        };
-
-        // Excel behaviour: #DIV/0! if no numeric values match
-        if count == 0 {
-            return CalcResult::Error {
-                error: Error::DIV,
-                origin: cell,
-                message: "No numeric values matched criteria".to_string(),
-            };
-        }
-
-        let n = count as f64;
-        let var = (sumsq - (sum * sum) / n) / n;
-        let var = if var < 0.0 { 0.0 } else { var };
-        CalcResult::Number(var)
-    }
-
-    /// Resolve the "field" (2nd arg) to an absolute column index (i32) within the sheet.
-    /// Field can be a number (1-based index) or a header name (case-insensitive).
-    /// Returns the absolute column index, not a 1-based offset within the database range.
-    fn resolve_db_field_column(
-        &mut self,
-        db_left: CellReferenceIndex,
-        db_right: CellReferenceIndex,
-        field_arg: &Node,
-        cell: CellReferenceIndex,
-    ) -> Result<i32, CalcResult> {
-        let field_column_name = match self.evaluate_node_in_context(field_arg, cell) {
-            CalcResult::String(s) => s.to_lowercase(),
-            CalcResult::Number(index) => {
-                let index = index.floor() as i32;
-                if index < 1 || db_left.column + index - 1 > db_right.column {
-                    return Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Field index out of range".to_string(),
-                    });
-                }
-                return Ok(db_left.column + index - 1);
-            }
-            CalcResult::Boolean(b) => {
-                return if b {
-                    Ok(db_left.column)
-                } else {
-                    // Index 0 is out of range
-                    Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid field specifier".to_string(),
-                    })
-                };
-            }
-            error @ CalcResult::Error { .. } => {
-                return Err(error);
-            }
-            CalcResult::Range { .. } => {
-                return Err(CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                })
-            }
-            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-            CalcResult::Array(_) => {
-                return Err(CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                })
-            }
-        };
-
-        // We search in the database a column whose header matches field_column_name
-        for column in db_left.column..=db_right.column {
-            let v = self.evaluate_cell(CellReferenceIndex {
-                sheet: db_left.sheet,
-                row: db_left.row,
-                column,
-            });
-            match &v {
-                CalcResult::String(s) => {
-                    if s.to_lowercase() == field_column_name {
-                        return Ok(column);
-                    }
-                }
-                CalcResult::Number(n) => {
-                    if field_column_name == n.to_string() {
-                        return Ok(column);
-                    }
-                }
-                CalcResult::Boolean(b) => {
-                    if field_column_name == b.to_string() {
-                        return Ok(column);
-                    }
-                }
-                CalcResult::Error { .. }
-                | CalcResult::Range { .. }
-                | CalcResult::EmptyCell
-                | CalcResult::EmptyArg
-                | CalcResult::Array(_) => {}
-            }
-        }
-
-        Err(CalcResult::Error {
-            error: Error::VALUE,
-            origin: cell,
-            message: "Field header not found".to_string(),
-        })
-    }
-
-    /// Check whether a database row matches the criteria range.
-    /// Criteria logic: OR across criteria rows; AND across columns within a row.
-    fn db_row_matches_criteria(
-        &mut self,
-        db_left: CellReferenceIndex,
-        db_right: CellReferenceIndex,
-        row: i32,
-        criteria: (CellReferenceIndex, CellReferenceIndex),
-    ) -> bool {
-        let (c_left, c_right) = criteria;
-
-        // Read criteria headers (first row of criteria range)
-        // Map header name (lowercased) -> db column (if exists)
-        let mut crit_cols: Vec<i32> = Vec::new();
-        let mut header_count = 0;
-        // We cover the criteria table:
-        //  headerA | headerB | ...
-        //  critA1  | critA2  | ...
-        //  critB1  | critB2  | ...
-        //  ...
-        for column in c_left.column..=c_right.column {
-            let cell = CellReferenceIndex {
-                sheet: c_left.sheet,
-                row: c_left.row,
-                column,
-            };
-            let criteria_header = self.evaluate_cell(cell);
-            if let Ok(s) = self.cast_to_string(criteria_header, cell) {
-                // Non-empty string header. If the header is non string we skip it
-                header_count += 1;
-                let wanted = s.to_lowercase();
-
-                // Find corresponding Database column
-                let mut found = false;
-                for db_column in db_left.column..=db_right.column {
-                    let db_header = self.evaluate_cell(CellReferenceIndex {
-                        sheet: db_left.sheet,
-                        row: db_left.row,
-                        column: db_column,
-                    });
-                    if let Ok(hs) = self.cast_to_string(db_header, cell) {
-                        if hs.to_lowercase() == wanted {
-                            crit_cols.push(db_column);
-                            found = true;
-                            break;
-                        }
-                    }
-                }
-                if !found {
-                    // that means the criteria column has no matching DB column
-                    // If the criteria condition is empty then we remove this condition
-                    // otherwise this condition can never be satisfied
-                    // We evaluate all criteria rows to see if any is non-empty
-                    let mut has_non_empty = false;
-                    for r in (c_left.row + 1)..=c_right.row {
-                        let ccell = self.evaluate_cell(CellReferenceIndex {
-                            sheet: c_left.sheet,
-                            row: r,
-                            column,
-                        });
-                        if !matches!(ccell, CalcResult::EmptyCell | CalcResult::EmptyArg) {
-                            has_non_empty = true;
-                            break;
-                        }
-                    }
-                    if has_non_empty {
-                        // This criteria column can never be satisfied
-                        header_count -= 1;
-                    }
-                }
-            };
-        }
-
-        if c_right.row <= c_left.row {
-            // If no criteria rows (only headers), everything matches
-            return true;
-        }
-
-        if header_count == 0 {
-            // If there are not "String" headers, nothing matches
-            // NB: There might be String headers that do not match any DB columns,
-            // in that case everything matches.
-            return false;
-        }
-
-        // Evaluate each criteria row (OR)
-        for r in (c_left.row + 1)..=c_right.row {
-            // AND across columns for this criteria row
-            let mut and_ok = true;
-
-            for (offset, db_col) in crit_cols.iter().enumerate() {
-                // Criteria cell
-                let ccell = self.evaluate_cell(CellReferenceIndex {
-                    sheet: c_left.sheet,
-                    row: r,
-                    column: c_left.column + offset as i32,
-                });
-
-                // Empty criteria cell -> ignored
-                if matches!(ccell, CalcResult::EmptyCell | CalcResult::EmptyArg) {
-                    continue;
-                }
-
-                // Database value for this row/column
-                let db_val = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: *db_col,
-                });
-
-                if !self.criteria_cell_matches(&db_val, &ccell) {
-                    and_ok = false;
-                    break;
-                }
-            }
-
-            if and_ok {
-                // This criteria row satisfied (OR)
-                return true;
-            }
-        }
-
-        // none matched
-        false
-    }
-
-    /// Implements Excel-like criteria matching for a single value.
-    /// Supports prefixes: <>, >=, <=, >, <, = ; wildcards * and ? for string equals.
-    fn criteria_cell_matches(&self, db_val: &CalcResult, crit_cell: &CalcResult) -> bool {
-        // Convert the criteria cell to a string for operator parsing if possible,
-        // otherwise fall back to equality via compare_values.
-
-        let mut criteria = match crit_cell {
-            CalcResult::String(s) => s.trim().to_string(),
-            CalcResult::Number(n) => {
-                // treat as equality with number
-                return match db_val {
-                    CalcResult::Number(v) => (*v - *n).abs() <= f64::EPSILON,
-                    _ => false,
-                };
-            }
-            CalcResult::Boolean(b) => {
-                // check equality with boolean
-                return match db_val {
-                    CalcResult::Boolean(v) => *v == *b,
-                    _ => false,
-                };
-            }
-            CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
-            CalcResult::Error { .. } => return false,
-            CalcResult::Range { .. } | CalcResult::Array(_) => return false,
-        };
-
-        // Detect operator prefix
-        let mut op = "="; // default equality (with wildcard semantics for strings)
-        let prefixes = ["<>", ">=", "<=", ">", "<", "="];
-        for p in prefixes.iter() {
-            if criteria.starts_with(p) {
-                op = p;
-                criteria = criteria[p.len()..].trim().to_string();
-                break;
-            }
-        }
-
-        // Is it a number?
-        let rhs_num = criteria.parse::<f64>().ok();
-
-        // Is it a date?
-        // FIXME: We should parse dates according to locale settings
-        let rhs_date = criteria.parse::<chrono::NaiveDate>().ok();
-
-        match op {
-            ">" | ">=" | "<" | "<=" => {
-                if let Some(d) = rhs_date {
-                    // date comparison
-                    let serial = match date_to_serial_number(d.day(), d.month(), d.year()) {
-                        Ok(sn) => sn as f64,
-                        Err(_) => return false,
-                    };
-
-                    if let CalcResult::Number(n) = db_val {
-                        match op {
-                            ">" => *n > serial,
-                            ">=" => *n >= serial,
-                            "<" => *n < serial,
-                            "<=" => *n <= serial,
-                            _ => false,
-                        }
-                    } else {
-                        false
-                    }
-                } else if let Some(t) = rhs_num {
-                    // numeric comparison
-                    if let CalcResult::Number(n) = db_val {
-                        match op {
-                            ">" => *n > t,
-                            ">=" => *n >= t,
-                            "<" => *n < t,
-                            "<=" => *n <= t,
-                            _ => false,
-                        }
-                    } else {
-                        false
-                    }
-                } else {
-                    // string comparison (case-insensitive) using compare_values semantics
-                    let rhs = CalcResult::String(criteria.to_lowercase());
-                    let lhs = match db_val {
-                        CalcResult::String(s) => CalcResult::String(s.to_lowercase()),
-                        x => x.clone(),
-                    };
-                    let c = compare_values(&lhs, &rhs);
-                    match op {
-                        ">" => c > 0,
-                        ">=" => c >= 0,
-                        "<" => c < 0,
-                        "<=" => c <= 0,
-                        _ => false,
-                    }
-                }
-            }
-            "<>" => {
-                // not equal (with wildcard semantics for strings)
-                // If rhs has wildcards and db_val is string, do regex; else use compare_values != 0
-                if let CalcResult::String(s) = db_val {
-                    if criteria.contains('*') || criteria.contains('?') {
-                        if let Ok(re) = from_wildcard_to_regex(&criteria.to_lowercase(), true) {
-                            return !result_matches_regex(
-                                &CalcResult::String(s.to_lowercase()),
-                                &re,
-                            );
-                        }
-                    }
-                }
-                let rhs = if let Some(n) = rhs_num {
-                    CalcResult::Number(n)
-                } else {
-                    CalcResult::String(criteria.to_lowercase())
-                };
-                let lhs = match db_val {
-                    CalcResult::String(s) => CalcResult::String(s.to_lowercase()),
-                    x => x.clone(),
-                };
-                compare_values(&lhs, &rhs) != 0
-            }
-            _ => {
-                // equality. For strings, support wildcards (*, ?)
-                if let Some(n) = rhs_num {
-                    // numeric equals
-                    if let CalcResult::Number(m) = db_val {
-                        (*m - n).abs() <= f64::EPSILON
-                    } else {
-                        compare_values(db_val, &CalcResult::Number(n)) == 0
-                    }
-                } else {
-                    // textual/boolean equals (case-insensitive), wildcard-enabled for strings
-                    if let CalcResult::String(s) = db_val {
-                        if criteria.contains('*') || criteria.contains('?') {
-                            if let Ok(re) = from_wildcard_to_regex(&criteria.to_lowercase(), true) {
-                                return result_matches_regex(
-                                    &CalcResult::String(s.to_lowercase()),
-                                    &re,
-                                );
-                            }
-                        }
-                        // This is weird but we only need to check if "starts with" for equality
-                        return s.to_lowercase().starts_with(&criteria.to_lowercase());
-                    }
-                    // Fallback: compare_values equality
-                    compare_values(db_val, &CalcResult::String(criteria.to_lowercase())) == 0
-                }
-            }
-        }
-    }
-
-    /// Shared implementation for DMAX/DMIN
-    fn db_extreme(
-        &mut self,
-        args: &[Node],
-        cell: CellReferenceIndex,
-        want_max: bool,
-    ) -> CalcResult {
-        if args.len() != 3 {
-            return CalcResult::new_args_number_error(cell);
-        }
-
-        let (db_left, db_right) = match self.get_reference(&args[0], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        let field_col = match self.resolve_db_field_column(db_left, db_right, &args[1], cell) {
-            Ok(c) => c,
-            Err(e) => return e,
-        };
-
-        let criteria = match self.get_reference(&args[2], cell) {
-            Ok(r) => (r.left, r.right),
-            Err(e) => return e,
-        };
-
-        if db_right.row <= db_left.row {
-            // no data rows
-            return CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "No data rows in database".to_string(),
-            };
-        }
-
-        let mut best: Option<f64> = None;
-
-        let mut row = db_left.row + 1;
-        while row <= db_right.row {
-            if self.db_row_matches_criteria(db_left, db_right, row, criteria) {
-                let v = self.evaluate_cell(CellReferenceIndex {
-                    sheet: db_left.sheet,
-                    row,
-                    column: field_col,
-                });
-                if let CalcResult::Number(value) = v {
-                    if value.is_finite() {
-                        best = Some(match best {
-                            None => value,
-                            Some(cur) => {
-                                if want_max {
-                                    value.max(cur)
-                                } else {
-                                    value.min(cur)
-                                }
-                            }
-                        });
-                    }
-                }
-            }
-            row += 1;
-        }
-
-        match best {
-            Some(v) => CalcResult::Number(v),
-            None => CalcResult::Number(0.0),
-        }
-    }
-}

base/src/functions/engineering/bessel.rs

@@ -1,12 +1,10 @@
-use statrs::function::erf::{erf, erfc};
-
 use crate::{
     calc_result::CalcResult,
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     model::Model,
 };
 
-use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y};
+use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y, erf};
 // https://root.cern/doc/v610/TMath_8cxx_source.html
 
 // Notice that the parameters for Bessel functions in Excel and here have inverted order
@@ -162,7 +160,7 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(erfc(x))
+        CalcResult::Number(1.0 - erf(x))
     }
 
     pub(crate) fn fn_erfcprecise(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -173,6 +171,6 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        CalcResult::Number(erfc(x))
+        CalcResult::Number(1.0 - erf(x))
     }
 }

base/src/functions/engineering/complex.rs

@@ -46,18 +46,18 @@ impl fmt::Display for Complex {
         // it is a bit weird what Excel does but it seems it uses general notation for
         // numbers > 1e-20 and scientific notation for the rest
         let y_str = if y.abs() <= 9e-20 {
-            format!("{y:E}")
+            format!("{:E}", y)
         } else if y == 1.0 {
             "".to_string()
         } else if y == -1.0 {
             "-".to_string()
         } else {
-            format!("{y}")
+            format!("{}", y)
         };
         let x_str = if x.abs() <= 9e-20 {
-            format!("{x:E}")
+            format!("{:E}", x)
         } else {
-            format!("{x}")
+            format!("{}", x)
         };
         if y == 0.0 && x == 0.0 {
             write!(f, "0")

base/src/functions/engineering/number_basis.rs

@@ -76,7 +76,7 @@ impl Model {
         if value < 0 {
             CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9))
         } else {
-            let result = format!("{value:X}");
+            let result = format!("{:X}", value);
             if let Some(places) = places {
                 if places < result.len() as i32 {
                     return CalcResult::new_error(
@@ -120,7 +120,7 @@ impl Model {
         if value < 0 {
             CalcResult::String(format!("{:0width$o}", OCT_MAX + value, width = 9))
         } else {
-            let result = format!("{value:o}");
+            let result = format!("{:o}", value);
             if let Some(places) = places {
                 if places < result.len() as i32 {
                     return CalcResult::new_error(
@@ -163,7 +163,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{value:b}");
+        let result = format!("{:b}", value);
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -202,7 +202,7 @@ impl Model {
         if value < 0 {
             value += HEX_MAX;
         }
-        let result = format!("{value:X}");
+        let result = format!("{:X}", value);
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -242,7 +242,7 @@ impl Model {
         if value < 0 {
             value += OCT_MAX;
         }
-        let result = format!("{value:o}");
+        let result = format!("{:o}", value);
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -301,7 +301,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{value:b}");
+        let result = format!("{:b}", value);
         if let Some(places) = places {
             if places <= 0 || (value > 0 && places < result.len() as i32) {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -391,7 +391,7 @@ impl Model {
         if value < 0 {
             value += OCT_MAX;
         }
-        let result = format!("{value:o}");
+        let result = format!("{:o}", value);
         if let Some(places) = places {
             if places <= 0 || (value > 0 && places < result.len() as i32) {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -446,7 +446,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{value:b}");
+        let result = format!("{:b}", value);
         if let Some(places) = places {
             if value < 512 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -532,7 +532,7 @@ impl Model {
         if value < 0 {
             value += HEX_MAX;
         }
-        let result = format!("{value:X}");
+        let result = format!("{:X}", value);
         if let Some(places) = places {
             if value < HEX_MAX_HALF && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());

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

@@ -0,0 +1,53 @@
+pub(crate) fn erf(x: f64) -> f64 {
+    let cof = vec![
+        -1.3026537197817094,
+        6.419_697_923_564_902e-1,
+        1.9476473204185836e-2,
+        -9.561_514_786_808_63e-3,
+        -9.46595344482036e-4,
+        3.66839497852761e-4,
+        4.2523324806907e-5,
+        -2.0278578112534e-5,
+        -1.624290004647e-6,
+        1.303655835580e-6,
+        1.5626441722e-8,
+        -8.5238095915e-8,
+        6.529054439e-9,
+        5.059343495e-9,
+        -9.91364156e-10,
+        -2.27365122e-10,
+        9.6467911e-11,
+        2.394038e-12,
+        -6.886027e-12,
+        8.94487e-13,
+        3.13092e-13,
+        -1.12708e-13,
+        3.81e-16,
+        7.106e-15,
+        -1.523e-15,
+        -9.4e-17,
+        1.21e-16,
+        -2.8e-17,
+    ];
+
+    let mut d = 0.0;
+    let mut dd = 0.0;
+
+    let x_abs = x.abs();
+
+    let t = 2.0 / (2.0 + x_abs);
+    let ty = 4.0 * t - 2.0;
+
+    for j in (1..=cof.len() - 1).rev() {
+        let tmp = d;
+        d = ty * d - dd + cof[j];
+        dd = tmp;
+    }
+
+    let res = t * f64::exp(-x_abs * x_abs + 0.5 * (cof[0] + ty * d) - dd);
+    if x < 0.0 {
+        res - 1.0
+    } else {
+        1.0 - res
+    }
+}

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

@@ -4,6 +4,7 @@ mod bessel_j1_y1;
 mod bessel_jn_yn;
 mod bessel_k;
 mod bessel_util;
+mod erf;
 
 #[cfg(test)]
 mod test_bessel;
@@ -12,3 +13,4 @@ pub(crate) use bessel_i::bessel_i;
 pub(crate) use bessel_jn_yn::jn as bessel_j;
 pub(crate) use bessel_jn_yn::yn as bessel_y;
 pub(crate) use bessel_k::bessel_k;
+pub(crate) use erf::erf;

base/src/functions/financial.rs

@@ -231,7 +231,7 @@ impl Model {
                             CalcResult::new_error(
                                 Error::ERROR,
                                 *cell,
-                                format!("Invalid worksheet index: '{sheet}'"),
+                                format!("Invalid worksheet index: '{}'", sheet),
                             )
                         })?
                         .dimension()
@@ -245,7 +245,7 @@ impl Model {
                             CalcResult::new_error(
                                 Error::ERROR,
                                 *cell,
-                                format!("Invalid worksheet index: '{sheet}'"),
+                                format!("Invalid worksheet index: '{}'", sheet),
                             )
                         })?
                         .dimension()

base/src/functions/information.rs

@@ -1,6 +1,6 @@
 use crate::{
     calc_result::CalcResult,
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex, utils::number_to_column},
+    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     model::{Model, ParsedDefinedName},
 };
 
@@ -320,150 +320,4 @@ impl Model {
             message: "Invalid name".to_string(),
         }
     }
-
-    pub(crate) fn fn_n(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let arg_count = args.len();
-        if arg_count != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(n) => n,
-            CalcResult::String(_) => 0.0,
-            CalcResult::Boolean(f) => {
-                if f {
-                    1.0
-                } else {
-                    0.0
-                }
-            }
-            CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
-            error @ CalcResult::Error { .. } => return error,
-            CalcResult::Range { .. } => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                }
-            }
-            CalcResult::Array(_) => {
-                return CalcResult::Error {
-                    error: Error::NIMPL,
-                    origin: cell,
-                    message: "Arrays not supported yet".to_string(),
-                }
-            }
-        };
-
-        CalcResult::Number(value)
-    }
-
-    pub(crate) fn fn_sheets(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let arg_count = args.len();
-        if arg_count > 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        if arg_count == 1 {
-            return CalcResult::Error {
-                error: Error::NIMPL,
-                origin: cell,
-                message: "Sheets function with an argument is not implemented".to_string(),
-            };
-        }
-        let sheet_count = self.workbook.worksheets.len() as f64;
-        CalcResult::Number(sheet_count)
-    }
-
-    pub(crate) fn fn_cell(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let arg_count = args.len();
-        if arg_count == 0 || arg_count > 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let reference = if arg_count == 2 {
-            match self.evaluate_node_with_reference(&args[1], cell) {
-                CalcResult::Range { left, right: _ } => {
-                    // we just take the left cell of the range
-                    left
-                }
-                _ => {
-                    return CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Argument must be a reference".to_string(),
-                    }
-                }
-            }
-        } else {
-            CellReferenceIndex {
-                sheet: cell.sheet,
-                row: cell.row,
-                column: cell.column,
-            }
-        };
-        let info_type = match self.get_string(&args[0], cell) {
-            Ok(s) => s.to_uppercase(),
-            Err(e) => return e,
-        };
-        match info_type.as_str() {
-            "ADDRESS" => {
-                if reference.sheet != cell.sheet {
-                    return CalcResult::Error {
-                        error: Error::NIMPL,
-                        origin: cell,
-                        message: "References to other sheets not implemented".to_string(),
-                    };
-                }
-                let column = match number_to_column(reference.column) {
-                    Some(c) => c,
-                    None => {
-                        return CalcResult::Error {
-                            error: Error::VALUE,
-                            origin: cell,
-                            message: "Invalid column".to_string(),
-                        }
-                    }
-                };
-                let address = format!("${}${}", column, reference.row);
-                CalcResult::String(address)
-            }
-            "COL" => CalcResult::Number(reference.column as f64),
-            "COLOR" | "FILENAME" | "FORMAT" | "PARENTHESES" | "PREFIX" | "PROTECT" | "WIDTH" => {
-                CalcResult::Error {
-                    error: Error::VALUE,
-                    origin: cell,
-                    message: "info_type not implemented".to_string(),
-                }
-            }
-            "CONTENTS" => self.evaluate_cell(reference),
-            "ROW" => CalcResult::Number(reference.row as f64),
-            "TYPE" => {
-                let cell_type = match self.evaluate_cell(reference) {
-                    CalcResult::EmptyCell => "b",
-                    CalcResult::String(_) => "l",
-                    CalcResult::Number(_) => "v",
-                    CalcResult::Boolean(_) => "v",
-                    CalcResult::Error { .. } => "v",
-                    CalcResult::Range { .. } => "v",
-                    CalcResult::EmptyArg => "v",
-                    CalcResult::Array(_) => "v",
-                };
-                CalcResult::String(cell_type.to_string())
-            }
-            _ => CalcResult::Error {
-                error: Error::VALUE,
-                origin: cell,
-                message: "Invalid info_type".to_string(),
-            },
-        }
-    }
-
-    pub(crate) fn fn_info(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.is_empty() || args.len() > 2 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        CalcResult::Error {
-            error: Error::NIMPL,
-            origin: cell,
-            message: "Info function not implemented".to_string(),
-        }
-    }
 }

base/src/functions/logical.rs

@@ -246,7 +246,7 @@ impl Model {
         }
         // None of the cases matched so we return the default
         // If there is an even number of args is the last one otherwise is #N/A
-        if args_count.is_multiple_of(2) {
+        if args_count % 2 == 0 {
             return self.evaluate_node_in_context(&args[args_count - 1], cell);
         }
         CalcResult::Error {
@@ -262,7 +262,7 @@ impl Model {
         if args_count < 2 {
             return CalcResult::new_args_number_error(cell);
         }
-        if !args_count.is_multiple_of(2) {
+        if args_count % 2 != 0 {
             // Missing value for last condition
             return CalcResult::new_args_number_error(cell);
         }

base/src/functions/macros.rs

@@ -68,14 +68,14 @@ macro_rules! single_number_fn {
                                 },
                                 // If String, parse to f64 then apply or #VALUE! error
                                 ArrayNode::String(s) => {
-                                    let node = match self.cast_number(&s) {
+                                    let node = match s.parse::<f64>() {
-                                        Some(f) => match $op(f) {
+                                        Ok(f) => match $op(f) {
                                             Ok(x) => ArrayNode::Number(x),
                                             Err(Error::DIV) => ArrayNode::Error(Error::DIV),
                                             Err(Error::VALUE) => ArrayNode::Error(Error::VALUE),
                                             Err(e) => ArrayNode::Error(e),
                                         },
-                                        None => ArrayNode::Error(Error::VALUE),
+                                        Err(_) => ArrayNode::Error(Error::VALUE),
                                     };
                                     data_row.push(node);
                                 }

base/src/functions/math_util.rs

@@ -1,200 +0,0 @@
-/// Parse Roman (classic or Excel variants) → number
-pub fn from_roman(s: &str) -> Result<u32, String> {
-    if s.is_empty() {
-        return Err("empty numeral".into());
-    }
-    fn val(c: char) -> Option<u32> {
-        Some(match c {
-            'I' => 1,
-            'V' => 5,
-            'X' => 10,
-            'L' => 50,
-            'C' => 100,
-            'D' => 500,
-            'M' => 1000,
-            _ => return None,
-        })
-    }
-
-    // Accept the union of subtractive pairs used by the tables above (Excel-compatible).
-    fn allowed_subtractive(a: char, b: char) -> bool {
-        matches!(
-            (a, b),
-            // classic:
-            ('I','V')|('I','X')|('X','L')|('X','C')|('C','D')|('C','M')
-            // Excel forms:
-            |('V','L')|('L','D')|('L','M') // VL, LD, LM
-            |('X','D')|('X','M')          // XD, XM
-            |('V','M')                    // VM
-            |('I','L')|('I','C')|('I','D')|('I','M') // IL, IC, ID, IM
-            |('V','D')|('V','C') // VD, VC
-        )
-    }
-
-    let chars: Vec<char> = s.chars().map(|c| c.to_ascii_uppercase()).collect();
-    let mut total = 0u32;
-    let mut i = 0usize;
-
-    // Repetition rules similar to classic Romans:
-    // V, L, D cannot repeat; I, X, C, M max 3 in a row.
-    let mut last_char: Option<char> = None;
-    let mut run_len = 0usize;
-
-    while i < chars.len() {
-        let c = chars[i];
-        let v = val(c).ok_or_else(|| format!("invalid character '{c}'"))?;
-
-        if Some(c) == last_char {
-            run_len += 1;
-            match c {
-                'V' | 'L' | 'D' => return Err(format!("invalid repetition of '{c}'")),
-                _ if run_len >= 3 => return Err(format!("invalid repetition of '{c}'")),
-                _ => {}
-            }
-        } else {
-            last_char = Some(c);
-            run_len = 0;
-        }
-
-        if i + 1 < chars.len() {
-            let c2 = chars[i + 1];
-            let v2 = val(c2).ok_or_else(|| format!("invalid character '{c2}'"))?;
-            if v < v2 {
-                if !allowed_subtractive(c, c2) {
-                    return Err(format!("invalid subtractive pair '{c}{c2}'"));
-                }
-                // Disallow stacked subtractives like IIV, XXL:
-                if run_len > 0 {
-                    return Err(format!("malformed numeral near position {i}"));
-                }
-                total += v2 - v;
-                i += 2;
-                last_char = None;
-                run_len = 0;
-                continue;
-            }
-        }
-
-        total += v;
-        i += 1;
-    }
-    Ok(total)
-}
-
-/// Classic Roman (strict) encoder used as a base for all forms.
-fn to_roman(mut n: u32) -> Result<String, String> {
-    if !(1..=3999).contains(&n) {
-        return Err("value out of range (must be 1..=3999)".into());
-    }
-
-    const MAP: &[(u32, &str)] = &[
-        (1000, "M"),
-        (900, "CM"),
-        (500, "D"),
-        (400, "CD"),
-        (100, "C"),
-        (90, "XC"),
-        (50, "L"),
-        (40, "XL"),
-        (10, "X"),
-        (9, "IX"),
-        (5, "V"),
-        (4, "IV"),
-        (1, "I"),
-    ];
-
-    let mut out = String::with_capacity(15);
-    for &(val, sym) in MAP {
-        while n >= val {
-            out.push_str(sym);
-            n -= val;
-        }
-        if n == 0 {
-            break;
-        }
-    }
-    Ok(out)
-}
-
-/// Excel/Google Sheets compatible ROMAN(number, [form]) encoder.
-/// `form`: 0..=4 (0=Classic, 4=Simplified).
-pub fn to_roman_with_form(n: u32, form: i32) -> Result<String, String> {
-    let mut s = to_roman(n)?;
-    if form == 0 {
-        return Ok(s);
-    }
-    if !(0..=4).contains(&form) {
-        return Err("form must be between 0 and 4".into());
-    }
-
-    // Base rules (apply for all f >= 1)
-    let base_rules: &[(&str, &str)] = &[
-        // C(D|M)XC -> L$1XL
-        ("CDXC", "LDXL"),
-        ("CMXC", "LMXL"),
-        // C(D|M)L -> L$1
-        ("CDL", "LD"),
-        ("CML", "LM"),
-        // X(L|C)IX -> V$1IV
-        ("XLIX", "VLIV"),
-        ("XCIX", "VCIV"),
-        // X(L|C)V -> V$1
-        ("XLV", "VL"),
-        ("XCV", "VC"),
-    ];
-
-    // Level 2 extra rules
-    let lvl2_rules: &[(&str, &str)] = &[
-        // V(L|C)IV -> I$1
-        ("VLIV", "IL"),
-        ("VCIV", "IC"),
-        // L(D|M)XL -> X$1
-        ("LDXL", "XD"),
-        ("LMXL", "XM"),
-        // L(D|M)VL -> X$1V
-        ("LDVL", "XDV"),
-        ("LMVL", "XMV"),
-        // L(D|M)IL -> X$1IX
-        ("LDIL", "XDIX"),
-        ("LMIL", "XMIX"),
-    ];
-
-    // Level 3 extra rules
-    let lvl3_rules: &[(&str, &str)] = &[
-        // X(D|M)V -> V$1
-        ("XDV", "VD"),
-        ("XMV", "VM"),
-        // X(D|M)IX -> V$1IV
-        ("XDIX", "VDIV"),
-        ("XMIX", "VMIV"),
-    ];
-
-    // Level 4 extra rules
-    let lvl4_rules: &[(&str, &str)] = &[
-        // V(D|M)IV -> I$1
-        ("VDIV", "ID"),
-        ("VMIV", "IM"),
-    ];
-
-    // Helper to apply a batch of (from -> to) globally, in order.
-    fn apply_rules(mut t: String, rules: &[(&str, &str)]) -> String {
-        for (from, to) in rules {
-            if t.contains(from) {
-                t = t.replace(from, to);
-            }
-        }
-        t
-    }
-
-    s = apply_rules(s, base_rules);
-    if form >= 2 {
-        s = apply_rules(s, lvl2_rules);
-    }
-    if form >= 3 {
-        s = apply_rules(s, lvl3_rules);
-    }
-    if form >= 4 {
-        s = apply_rules(s, lvl4_rules);
-    }
-    Ok(s)
-}

base/src/functions/mod.rs

@@ -8,7 +8,6 @@ use crate::{
 };
 
 pub(crate) mod binary_search;
-mod database;
 mod date_and_time;
 mod engineering;
 mod financial;
@@ -17,7 +16,6 @@ mod information;
 mod logical;
 mod lookup_and_reference;
 mod macros;
-mod math_util;
 mod mathematical;
 mod statistical;
 mod subtotal;
@@ -56,9 +54,6 @@ pub enum Function {
     Columns,
     Cos,
     Cosh,
-    Log,
-    Log10,
-    Ln,
     Max,
     Min,
     Pi,
@@ -78,43 +73,6 @@ pub enum Function {
     Sumifs,
     Tan,
     Tanh,
-    Acot,
-    Acoth,
-    Cot,
-    Coth,
-    Csc,
-    Csch,
-    Sec,
-    Sech,
-    Exp,
-    Fact,
-    Factdouble,
-    Sign,
-    Radians,
-    Degrees,
-    Int,
-    Even,
-    Odd,
-    Ceiling,
-    CeilingMath,
-    CeilingPrecise,
-    Floor,
-    FloorMath,
-    FloorPrecise,
-    IsoCeiling,
-    Mod,
-    Quotient,
-    Mround,
-    Trunc,
-    Gcd,
-    Lcm,
-    Base,
-    Decimal,
-    Roman,
-    Arabic,
-    Combin,
-    Combina,
-    Sumsq,
 
     // Information
     ErrorType,
@@ -135,11 +93,6 @@ pub enum Function {
     Sheet,
     Type,
 
-    Sheets,
-    N,
-    Cell,
-    Info,
-
     // Lookup and reference
     Hlookup,
     Index,
@@ -192,30 +145,13 @@ pub enum Function {
 
     // Date and time
     Date,
-    Datedif,
-    Datevalue,
     Day,
     Edate,
     Eomonth,
     Month,
-    Time,
-    Timevalue,
-    Hour,
-    Minute,
-    Second,
     Now,
     Today,
     Year,
-    Networkdays,
-    NetworkdaysIntl,
-    Days,
-    Days360,
-    Weekday,
-    Weeknum,
-    Workday,
-    WorkdayIntl,
-    Yearfrac,
-    Isoweeknum,
 
     // Financial
     Cumipmt,
@@ -311,24 +247,10 @@ pub enum Function {
     Delta,
     Gestep,
     Subtotal,
-
-    // Database
-    Daverage,
-    Dcount,
-    Dget,
-    Dmax,
-    Dmin,
-    Dsum,
-    Dcounta,
-    Dproduct,
-    Dstdev,
-    Dvar,
-    Dvarp,
-    Dstdevp,
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 268> {
+    pub fn into_iter() -> IntoIter<Function, 195> {
         [
             Function::And,
             Function::False,
@@ -355,50 +277,15 @@ impl Function {
             Function::Atanh,
             Function::Abs,
             Function::Pi,
-            Function::Ln,
-            Function::Log,
-            Function::Log10,
             Function::Sqrt,
             Function::Sqrtpi,
             Function::Atan2,
-            Function::Acot,
-            Function::Acoth,
-            Function::Cot,
-            Function::Coth,
-            Function::Csc,
-            Function::Csch,
-            Function::Sec,
-            Function::Sech,
             Function::Power,
-            Function::Exp,
-            Function::Fact,
-            Function::Factdouble,
-            Function::Sign,
-            Function::Int,
-            Function::Even,
-            Function::Odd,
-            Function::Ceiling,
-            Function::CeilingMath,
-            Function::CeilingPrecise,
-            Function::Floor,
-            Function::FloorMath,
-            Function::FloorPrecise,
-            Function::IsoCeiling,
-            Function::Mod,
-            Function::Quotient,
-            Function::Mround,
-            Function::Trunc,
-            Function::Gcd,
-            Function::Lcm,
-            Function::Base,
-            Function::Decimal,
             Function::Max,
             Function::Min,
             Function::Product,
             Function::Rand,
             Function::Randbetween,
-            Function::Radians,
-            Function::Degrees,
             Function::Round,
             Function::Rounddown,
             Function::Roundup,
@@ -469,26 +356,9 @@ impl Function {
             Function::Month,
             Function::Eomonth,
             Function::Date,
-            Function::Datedif,
-            Function::Datevalue,
             Function::Edate,
-            Function::Networkdays,
-            Function::NetworkdaysIntl,
-            Function::Time,
-            Function::Timevalue,
-            Function::Hour,
-            Function::Minute,
-            Function::Second,
             Function::Today,
             Function::Now,
-            Function::Days,
-            Function::Days360,
-            Function::Weekday,
-            Function::Weeknum,
-            Function::Workday,
-            Function::WorkdayIntl,
-            Function::Yearfrac,
-            Function::Isoweeknum,
             Function::Pmt,
             Function::Pv,
             Function::Rate,
@@ -577,27 +447,6 @@ impl Function {
             Function::Delta,
             Function::Gestep,
             Function::Subtotal,
-            Function::Roman,
-            Function::Arabic,
-            Function::Combin,
-            Function::Combina,
-            Function::Sumsq,
-            Function::N,
-            Function::Cell,
-            Function::Info,
-            Function::Sheets,
-            Function::Daverage,
-            Function::Dcount,
-            Function::Dget,
-            Function::Dmax,
-            Function::Dmin,
-            Function::Dsum,
-            Function::Dcounta,
-            Function::Dproduct,
-            Function::Dstdev,
-            Function::Dvar,
-            Function::Dvarp,
-            Function::Dstdevp,
         ]
         .into_iter()
     }
@@ -639,27 +488,6 @@ impl Function {
             Function::Isformula => "_xlfn.ISFORMULA".to_string(),
             Function::Sheet => "_xlfn.SHEET".to_string(),
             Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
-            Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
-            Function::Ceiling => "_xlfn.CEILING".to_string(),
-            Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
-            Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
-            Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
-            Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
-            Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
-            Function::Base => "_xlfn.BASE".to_string(),
-            Function::Decimal => "_xlfn.DECIMAL".to_string(),
-            Function::Arabic => "_xlfn.ARABIC".to_string(),
-            Function::Combina => "_xlfn.COMBINA".to_string(),
-            Function::Sheets => "_xlfn.SHEETS".to_string(),
-            Function::Acoth => "_xlfn.ACOTH".to_string(),
-            Function::Cot => "_xlfn.COT".to_string(),
-            Function::Coth => "_xlfn.COTH".to_string(),
-            Function::Csc => "_xlfn.CSC".to_string(),
-            Function::Csch => "_xlfn.CSCH".to_string(),
-            Function::Sec => "_xlfn.SEC".to_string(),
-            Function::Sech => "_xlfn.SECH".to_string(),
-            Function::Acot => "_xlfn.ACOT".to_string(),
-
             _ => self.to_string(),
         }
     }
@@ -682,61 +510,30 @@ impl Function {
             "SWITCH" | "_XLFN.SWITCH" => Some(Function::Switch),
             "TRUE" => Some(Function::True),
             "XOR" | "_XLFN.XOR" => Some(Function::Xor),
+
             "SIN" => Some(Function::Sin),
             "COS" => Some(Function::Cos),
             "TAN" => Some(Function::Tan),
+
             "ASIN" => Some(Function::Asin),
             "ACOS" => Some(Function::Acos),
             "ATAN" => Some(Function::Atan),
+
             "SINH" => Some(Function::Sinh),
             "COSH" => Some(Function::Cosh),
             "TANH" => Some(Function::Tanh),
+
             "ASINH" => Some(Function::Asinh),
             "ACOSH" => Some(Function::Acosh),
             "ATANH" => Some(Function::Atanh),
-            "ACOT" | "_XLFN.ACOT" => Some(Function::Acot),
+
-            "COTH" | "_XLFN.COTH" => Some(Function::Coth),
-            "COT" | "_XLFN.COT" => Some(Function::Cot),
-            "CSC" | "_XLFN.CSC" => Some(Function::Csc),
-            "CSCH" | "_XLFN.CSCH" => Some(Function::Csch),
-            "SEC" | "_XLFN.SEC" => Some(Function::Sec),
-            "SECH" | "_XLFN.SECH" => Some(Function::Sech),
-            "ACOTH" | "_XLFN.ACOTH" => Some(Function::Acoth),
-            "FACT" => Some(Function::Fact),
-            "FACTDOUBLE" => Some(Function::Factdouble),
-            "EXP" => Some(Function::Exp),
-            "SIGN" => Some(Function::Sign),
-            "RADIANS" => Some(Function::Radians),
-            "DEGREES" => Some(Function::Degrees),
-            "INT" => Some(Function::Int),
-            "EVEN" => Some(Function::Even),
-            "ODD" => Some(Function::Odd),
-            "CEILING" | "_XLFN.CEILING" => Some(Function::Ceiling),
-            "CEILING.MATH" | "_XLFN.CEILING.MATH" => Some(Function::CeilingMath),
-            "CEILING.PRECISE" | "_XLFN.CEILING.PRECISE" => Some(Function::CeilingPrecise),
-            "FLOOR" => Some(Function::Floor),
-            "FLOOR.MATH" | "_XLFN.FLOOR.MATH" => Some(Function::FloorMath),
-            "FLOOR.PRECISE" | "_XLFN.FLOOR.PRECISE" => Some(Function::FloorPrecise),
-            "ISO.CEILING" | "_XLFN.ISO.CEILING" => Some(Function::IsoCeiling),
-            "MOD" => Some(Function::Mod),
-            "QUOTIENT" => Some(Function::Quotient),
-            "MROUND" => Some(Function::Mround),
-            "TRUNC" => Some(Function::Trunc),
-            "GCD" => Some(Function::Gcd),
-            "LCM" => Some(Function::Lcm),
-            "BASE" | "_XLFN.BASE" => Some(Function::Base),
-            "DECIMAL" | "_XLFN.DECIMAL" => Some(Function::Decimal),
-            "ROMAN" => Some(Function::Roman),
-            "ARABIC" | "_XLFN.ARABIC" => Some(Function::Arabic),
             "PI" => Some(Function::Pi),
             "ABS" => Some(Function::Abs),
             "SQRT" => Some(Function::Sqrt),
             "SQRTPI" => Some(Function::Sqrtpi),
             "POWER" => Some(Function::Power),
             "ATAN2" => Some(Function::Atan2),
-            "LN" => Some(Function::Ln),
+
-            "LOG" => Some(Function::Log),
-            "LOG10" => Some(Function::Log10),
             "MAX" => Some(Function::Max),
             "MIN" => Some(Function::Min),
             "PRODUCT" => Some(Function::Product),
@@ -748,9 +545,6 @@ impl Function {
             "SUM" => Some(Function::Sum),
             "SUMIF" => Some(Function::Sumif),
             "SUMIFS" => Some(Function::Sumifs),
-            "COMBIN" => Some(Function::Combin),
-            "COMBINA" | "_XLFN.COMBINA" => Some(Function::Combina),
-            "SUMSQ" => Some(Function::Sumsq),
 
             // Lookup and Reference
             "CHOOSE" => Some(Function::Choose),
@@ -827,26 +621,9 @@ impl Function {
             "EOMONTH" => Some(Function::Eomonth),
             "MONTH" => Some(Function::Month),
             "DATE" => Some(Function::Date),
-            "DATEDIF" => Some(Function::Datedif),
-            "DATEVALUE" => Some(Function::Datevalue),
             "EDATE" => Some(Function::Edate),
-            "NETWORKDAYS" => Some(Function::Networkdays),
-            "NETWORKDAYS.INTL" => Some(Function::NetworkdaysIntl),
-            "TIME" => Some(Function::Time),
-            "TIMEVALUE" => Some(Function::Timevalue),
-            "HOUR" => Some(Function::Hour),
-            "MINUTE" => Some(Function::Minute),
-            "SECOND" => Some(Function::Second),
             "TODAY" => Some(Function::Today),
             "NOW" => Some(Function::Now),
-            "DAYS" | "_XLFN.DAYS" => Some(Function::Days),
-            "DAYS360" => Some(Function::Days360),
-            "WEEKDAY" => Some(Function::Weekday),
-            "WEEKNUM" => Some(Function::Weeknum),
-            "WORKDAY" => Some(Function::Workday),
-            "WORKDAY.INTL" => Some(Function::WorkdayIntl),
-            "YEARFRAC" => Some(Function::Yearfrac),
-            "ISOWEEKNUM" | "_XLFN.ISOWEEKNUM" => Some(Function::Isoweeknum),
             // Financial
             "PMT" => Some(Function::Pmt),
             "PV" => Some(Function::Pv),
@@ -938,25 +715,6 @@ impl Function {
             "GESTEP" => Some(Function::Gestep),
 
             "SUBTOTAL" => Some(Function::Subtotal),
-
-            "N" => Some(Function::N),
-            "CELL" => Some(Function::Cell),
-            "INFO" => Some(Function::Info),
-            "SHEETS" | "_XLFN.SHEETS" => Some(Function::Sheets),
-
-            "DAVERAGE" => Some(Function::Daverage),
-            "DCOUNT" => Some(Function::Dcount),
-            "DGET" => Some(Function::Dget),
-            "DMAX" => Some(Function::Dmax),
-            "DMIN" => Some(Function::Dmin),
-            "DSUM" => Some(Function::Dsum),
-            "DCOUNTA" => Some(Function::Dcounta),
-            "DPRODUCT" => Some(Function::Dproduct),
-            "DSTDEV" => Some(Function::Dstdev),
-            "DVAR" => Some(Function::Dvar),
-            "DVARP" => Some(Function::Dvarp),
-            "DSTDEVP" => Some(Function::Dstdevp),
-
             _ => None,
         }
     }
@@ -976,9 +734,6 @@ impl fmt::Display for Function {
             Function::Switch => write!(f, "SWITCH"),
             Function::True => write!(f, "TRUE"),
             Function::Xor => write!(f, "XOR"),
-            Function::Log => write!(f, "LOG"),
-            Function::Log10 => write!(f, "LOG10"),
-            Function::Ln => write!(f, "LN"),
             Function::Sin => write!(f, "SIN"),
             Function::Cos => write!(f, "COS"),
             Function::Tan => write!(f, "TAN"),
@@ -991,14 +746,6 @@ impl fmt::Display for Function {
             Function::Asinh => write!(f, "ASINH"),
             Function::Acosh => write!(f, "ACOSH"),
             Function::Atanh => write!(f, "ATANH"),
-            Function::Acot => write!(f, "ACOT"),
-            Function::Acoth => write!(f, "ACOTH"),
-            Function::Cot => write!(f, "COT"),
-            Function::Coth => write!(f, "COTH"),
-            Function::Csc => write!(f, "CSC"),
-            Function::Csch => write!(f, "CSCH"),
-            Function::Sec => write!(f, "SEC"),
-            Function::Sech => write!(f, "SECH"),
             Function::Abs => write!(f, "ABS"),
             Function::Pi => write!(f, "PI"),
             Function::Sqrt => write!(f, "SQRT"),
@@ -1063,6 +810,7 @@ impl fmt::Display for Function {
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
+
             Function::Average => write!(f, "AVERAGE"),
             Function::Averagea => write!(f, "AVERAGEA"),
             Function::Averageif => write!(f, "AVERAGEIF"),
@@ -1080,26 +828,9 @@ impl fmt::Display for Function {
             Function::Month => write!(f, "MONTH"),
             Function::Eomonth => write!(f, "EOMONTH"),
             Function::Date => write!(f, "DATE"),
-            Function::Datedif => write!(f, "DATEDIF"),
-            Function::Datevalue => write!(f, "DATEVALUE"),
             Function::Edate => write!(f, "EDATE"),
-            Function::Networkdays => write!(f, "NETWORKDAYS"),
-            Function::NetworkdaysIntl => write!(f, "NETWORKDAYS.INTL"),
-            Function::Time => write!(f, "TIME"),
-            Function::Timevalue => write!(f, "TIMEVALUE"),
-            Function::Hour => write!(f, "HOUR"),
-            Function::Minute => write!(f, "MINUTE"),
-            Function::Second => write!(f, "SECOND"),
             Function::Today => write!(f, "TODAY"),
             Function::Now => write!(f, "NOW"),
-            Function::Days => write!(f, "DAYS"),
-            Function::Days360 => write!(f, "DAYS360"),
-            Function::Weekday => write!(f, "WEEKDAY"),
-            Function::Weeknum => write!(f, "WEEKNUM"),
-            Function::Workday => write!(f, "WORKDAY"),
-            Function::WorkdayIntl => write!(f, "WORKDAY.INTL"),
-            Function::Yearfrac => write!(f, "YEARFRAC"),
-            Function::Isoweeknum => write!(f, "ISOWEEKNUM"),
             Function::Pmt => write!(f, "PMT"),
             Function::Pv => write!(f, "PV"),
             Function::Rate => write!(f, "RATE"),
@@ -1187,53 +918,8 @@ impl fmt::Display for Function {
             Function::Convert => write!(f, "CONVERT"),
             Function::Delta => write!(f, "DELTA"),
             Function::Gestep => write!(f, "GESTEP"),
-            Function::Subtotal => write!(f, "SUBTOTAL"),
-            Function::Exp => write!(f, "EXP"),
-            Function::Fact => write!(f, "FACT"),
-            Function::Factdouble => write!(f, "FACTDOUBLE"),
-            Function::Sign => write!(f, "SIGN"),
-            Function::Radians => write!(f, "RADIANS"),
-            Function::Degrees => write!(f, "DEGREES"),
-            Function::Int => write!(f, "INT"),
-            Function::Even => write!(f, "EVEN"),
-            Function::Odd => write!(f, "ODD"),
-            Function::Ceiling => write!(f, "CEILING"),
-            Function::CeilingMath => write!(f, "CEILING.MATH"),
-            Function::CeilingPrecise => write!(f, "CEILING.PRECISE"),
-            Function::Floor => write!(f, "FLOOR"),
-            Function::FloorMath => write!(f, "FLOOR.MATH"),
-            Function::FloorPrecise => write!(f, "FLOOR.PRECISE"),
-            Function::IsoCeiling => write!(f, "ISO.CEILING"),
-            Function::Mod => write!(f, "MOD"),
-            Function::Quotient => write!(f, "QUOTIENT"),
-            Function::Mround => write!(f, "MROUND"),
-            Function::Trunc => write!(f, "TRUNC"),
-            Function::Gcd => write!(f, "GCD"),
-            Function::Lcm => write!(f, "LCM"),
-            Function::Base => write!(f, "BASE"),
-            Function::Decimal => write!(f, "DECIMAL"),
-            Function::Roman => write!(f, "ROMAN"),
-            Function::Arabic => write!(f, "ARABIC"),
-            Function::Combin => write!(f, "COMBIN"),
-            Function::Combina => write!(f, "COMBINA"),
-            Function::Sumsq => write!(f, "SUMSQ"),
 
-            Function::N => write!(f, "N"),
+            Function::Subtotal => write!(f, "SUBTOTAL"),
-            Function::Cell => write!(f, "CELL"),
-            Function::Info => write!(f, "INFO"),
-            Function::Sheets => write!(f, "SHEETS"),
-            Function::Daverage => write!(f, "DAVERAGE"),
-            Function::Dcount => write!(f, "DCOUNT"),
-            Function::Dget => write!(f, "DGET"),
-            Function::Dmax => write!(f, "DMAX"),
-            Function::Dmin => write!(f, "DMIN"),
-            Function::Dsum => write!(f, "DSUM"),
-            Function::Dcounta => write!(f, "DCOUNTA"),
-            Function::Dproduct => write!(f, "DPRODUCT"),
-            Function::Dstdev => write!(f, "DSTDEV"),
-            Function::Dvar => write!(f, "DVAR"),
-            Function::Dvarp => write!(f, "DVARP"),
-            Function::Dstdevp => write!(f, "DSTDEVP"),
         }
     }
 }
@@ -1262,6 +948,7 @@ impl Model {
         cell: CellReferenceIndex,
     ) -> CalcResult {
         match kind {
+            // Logical
             Function::And => self.fn_and(args, cell),
             Function::False => self.fn_false(args, cell),
             Function::If => self.fn_if(args, cell),
@@ -1273,27 +960,31 @@ impl Model {
             Function::Switch => self.fn_switch(args, cell),
             Function::True => self.fn_true(args, cell),
             Function::Xor => self.fn_xor(args, cell),
-            Function::Log => self.fn_log(args, cell),
+            // Math and trigonometry
-            Function::Log10 => self.fn_log10(args, cell),
-            Function::Ln => self.fn_ln(args, cell),
             Function::Sin => self.fn_sin(args, cell),
             Function::Cos => self.fn_cos(args, cell),
             Function::Tan => self.fn_tan(args, cell),
+
             Function::Asin => self.fn_asin(args, cell),
             Function::Acos => self.fn_acos(args, cell),
             Function::Atan => self.fn_atan(args, cell),
+
             Function::Sinh => self.fn_sinh(args, cell),
             Function::Cosh => self.fn_cosh(args, cell),
             Function::Tanh => self.fn_tanh(args, cell),
+
             Function::Asinh => self.fn_asinh(args, cell),
             Function::Acosh => self.fn_acosh(args, cell),
             Function::Atanh => self.fn_atanh(args, cell),
+
             Function::Pi => self.fn_pi(args, cell),
             Function::Abs => self.fn_abs(args, cell),
+
             Function::Sqrt => self.fn_sqrt(args, cell),
             Function::Sqrtpi => self.fn_sqrtpi(args, cell),
             Function::Atan2 => self.fn_atan2(args, cell),
             Function::Power => self.fn_power(args, cell),
+
             Function::Max => self.fn_max(args, cell),
             Function::Min => self.fn_min(args, cell),
             Function::Product => self.fn_product(args, cell),
@@ -1305,6 +996,8 @@ impl Model {
             Function::Sum => self.fn_sum(args, cell),
             Function::Sumif => self.fn_sumif(args, cell),
             Function::Sumifs => self.fn_sumifs(args, cell),
+
+            // Lookup and Reference
             Function::Choose => self.fn_choose(args, cell),
             Function::Column => self.fn_column(args, cell),
             Function::Columns => self.fn_columns(args, cell),
@@ -1318,6 +1011,7 @@ impl Model {
             Function::Rows => self.fn_rows(args, cell),
             Function::Vlookup => self.fn_vlookup(args, cell),
             Function::Xlookup => self.fn_xlookup(args, cell),
+            // Text
             Function::Concatenate => self.fn_concatenate(args, cell),
             Function::Exact => self.fn_exact(args, cell),
             Function::Value => self.fn_value(args, cell),
@@ -1335,6 +1029,7 @@ impl Model {
             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),
             Function::Isnontext => self.fn_isnontext(args, cell),
             Function::Istext => self.fn_istext(args, cell),
@@ -1352,6 +1047,7 @@ impl Model {
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
+            // Statistical
             Function::Average => self.fn_average(args, cell),
             Function::Averagea => self.fn_averagea(args, cell),
             Function::Averageif => self.fn_averageif(args, cell),
@@ -1364,31 +1060,16 @@ impl Model {
             Function::Maxifs => self.fn_maxifs(args, cell),
             Function::Minifs => self.fn_minifs(args, cell),
             Function::Geomean => self.fn_geomean(args, cell),
+            // Date and Time
             Function::Year => self.fn_year(args, cell),
             Function::Day => self.fn_day(args, cell),
             Function::Eomonth => self.fn_eomonth(args, cell),
             Function::Month => self.fn_month(args, cell),
             Function::Date => self.fn_date(args, cell),
-            Function::Datedif => self.fn_datedif(args, cell),
-            Function::Datevalue => self.fn_datevalue(args, cell),
             Function::Edate => self.fn_edate(args, cell),
-            Function::Networkdays => self.fn_networkdays(args, cell),
-            Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
-            Function::Time => self.fn_time(args, cell),
-            Function::Timevalue => self.fn_timevalue(args, cell),
-            Function::Hour => self.fn_hour(args, cell),
-            Function::Minute => self.fn_minute(args, cell),
-            Function::Second => self.fn_second(args, cell),
             Function::Today => self.fn_today(args, cell),
             Function::Now => self.fn_now(args, cell),
-            Function::Days => self.fn_days(args, cell),
+            // Financial
-            Function::Days360 => self.fn_days360(args, cell),
-            Function::Weekday => self.fn_weekday(args, cell),
-            Function::Weeknum => self.fn_weeknum(args, cell),
-            Function::Workday => self.fn_workday(args, cell),
-            Function::WorkdayIntl => self.fn_workday_intl(args, cell),
-            Function::Yearfrac => self.fn_yearfrac(args, cell),
-            Function::Isoweeknum => self.fn_isoweeknum(args, cell),
             Function::Pmt => self.fn_pmt(args, cell),
             Function::Pv => self.fn_pv(args, cell),
             Function::Rate => self.fn_rate(args, cell),
@@ -1422,6 +1103,7 @@ impl Model {
             Function::Db => self.fn_db(args, cell),
             Function::Cumprinc => self.fn_cumprinc(args, cell),
             Function::Cumipmt => self.fn_cumipmt(args, cell),
+            // Engineering
             Function::Besseli => self.fn_besseli(args, cell),
             Function::Besselj => self.fn_besselj(args, cell),
             Function::Besselk => self.fn_besselk(args, cell),
@@ -1476,60 +1158,8 @@ impl Model {
             Function::Convert => self.fn_convert(args, cell),
             Function::Delta => self.fn_delta(args, cell),
             Function::Gestep => self.fn_gestep(args, cell),
+
             Function::Subtotal => self.fn_subtotal(args, cell),
-            Function::Acot => self.fn_acot(args, cell),
-            Function::Acoth => self.fn_acoth(args, cell),
-            Function::Cot => self.fn_cot(args, cell),
-            Function::Coth => self.fn_coth(args, cell),
-            Function::Csc => self.fn_csc(args, cell),
-            Function::Csch => self.fn_csch(args, cell),
-            Function::Sec => self.fn_sec(args, cell),
-            Function::Sech => self.fn_sech(args, cell),
-            Function::Exp => self.fn_exp(args, cell),
-            Function::Fact => self.fn_fact(args, cell),
-            Function::Factdouble => self.fn_factdouble(args, cell),
-            Function::Sign => self.fn_sign(args, cell),
-            Function::Radians => self.fn_radians(args, cell),
-            Function::Degrees => self.fn_degrees(args, cell),
-            Function::Int => self.fn_int(args, cell),
-            Function::Even => self.fn_even(args, cell),
-            Function::Odd => self.fn_odd(args, cell),
-            Function::Ceiling => self.fn_ceiling(args, cell),
-            Function::CeilingMath => self.fn_ceiling_math(args, cell),
-            Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
-            Function::Floor => self.fn_floor(args, cell),
-            Function::FloorMath => self.fn_floor_math(args, cell),
-            Function::FloorPrecise => self.fn_floor_precise(args, cell),
-            Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
-            Function::Mod => self.fn_mod(args, cell),
-            Function::Quotient => self.fn_quotient(args, cell),
-            Function::Mround => self.fn_mround(args, cell),
-            Function::Trunc => self.fn_trunc(args, cell),
-            Function::Gcd => self.fn_gcd(args, cell),
-            Function::Lcm => self.fn_lcm(args, cell),
-            Function::Base => self.fn_base(args, cell),
-            Function::Decimal => self.fn_decimal(args, cell),
-            Function::Roman => self.fn_roman(args, cell),
-            Function::Arabic => self.fn_arabic(args, cell),
-            Function::Combin => self.fn_combin(args, cell),
-            Function::Combina => self.fn_combina(args, cell),
-            Function::Sumsq => self.fn_sumsq(args, cell),
-            Function::N => self.fn_n(args, cell),
-            Function::Cell => self.fn_cell(args, cell),
-            Function::Info => self.fn_info(args, cell),
-            Function::Sheets => self.fn_sheets(args, cell),
-            Function::Daverage => self.fn_daverage(args, cell),
-            Function::Dcount => self.fn_dcount(args, cell),
-            Function::Dget => self.fn_dget(args, cell),
-            Function::Dmax => self.fn_dmax(args, cell),
-            Function::Dmin => self.fn_dmin(args, cell),
-            Function::Dsum => self.fn_dsum(args, cell),
-            Function::Dcounta => self.fn_dcounta(args, cell),
-            Function::Dproduct => self.fn_dproduct(args, cell),
-            Function::Dstdev => self.fn_dstdev(args, cell),
-            Function::Dvar => self.fn_dvar(args, cell),
-            Function::Dvarp => self.fn_dvarp(args, cell),
-            Function::Dstdevp => self.fn_dstdevp(args, cell),
         }
     }
 }
@@ -1584,7 +1214,7 @@ mod tests {
         }
         // 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('.', ""))
+            .map(|f| format!("{}", f).replace('.', ""))
             .collect::<Vec<_>>();
 
         let len = iter_list.len();

base/src/functions/statistical.rs

@@ -350,7 +350,7 @@ impl Model {
     // FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
     pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let args_count = args.len();
-        if args_count < 2 || !args_count.is_multiple_of(2) {
+        if args_count < 2 || args_count % 2 == 1 {
             return CalcResult::new_args_number_error(cell);
         }
 
@@ -476,7 +476,7 @@ impl Model {
         F: FnMut(f64),
     {
         let args_count = args.len();
-        if args_count < 3 || args_count.is_multiple_of(2) {
+        if args_count < 3 || args_count % 2 == 0 {
             return Err(CalcResult::new_args_number_error(cell));
         }
         let arg_0 = self.evaluate_node_in_context(&args[0], cell);

base/src/functions/text.rs

@@ -55,14 +55,14 @@ impl Model {
         let mut result = "".to_string();
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::String(value) => result = format!("{result}{value}"),
+                CalcResult::String(value) => result = format!("{}{}", result, value),
-                CalcResult::Number(value) => result = format!("{result}{value}"),
+                CalcResult::Number(value) => result = format!("{}{}", result, value),
                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                 CalcResult::Boolean(value) => {
                     if value {
-                        result = format!("{result}TRUE");
+                        result = format!("{}TRUE", result);
                     } else {
-                        result = format!("{result}FALSE");
+                        result = format!("{}FALSE", result);
                     }
                 }
                 error @ CalcResult::Error { .. } => return error,
@@ -82,14 +82,16 @@ impl Model {
                                 column,
                             }) {
                                 CalcResult::String(value) => {
-                                    result = format!("{result}{value}");
+                                    result = format!("{}{}", result, value);
+                                }
+                                CalcResult::Number(value) => {
+                                    result = format!("{}{}", result, value)
                                 }
-                                CalcResult::Number(value) => result = format!("{result}{value}"),
                                 CalcResult::Boolean(value) => {
                                     if value {
-                                        result = format!("{result}TRUE");
+                                        result = format!("{}TRUE", result);
                                     } else {
-                                        result = format!("{result}FALSE");
+                                        result = format!("{}FALSE", result);
                                     }
                                 }
                                 error @ CalcResult::Error { .. } => return error,
@@ -280,7 +282,7 @@ impl Model {
     pub(crate) fn fn_len(&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::Number(v) => format!("{}", v),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -315,7 +317,7 @@ impl Model {
     pub(crate) fn fn_trim(&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::Number(v) => format!("{}", v),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -350,7 +352,7 @@ impl Model {
     pub(crate) fn fn_lower(&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::Number(v) => format!("{}", v),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -385,7 +387,7 @@ impl Model {
     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::Number(v) => format!("{}", v),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -439,7 +441,7 @@ impl Model {
     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) {
-                CalcResult::Number(v) => format!("{v}"),
+                CalcResult::Number(v) => format!("{}", v),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -476,7 +478,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{v}"),
+            CalcResult::Number(v) => format!("{}", v),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -558,7 +560,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{v}"),
+            CalcResult::Number(v) => format!("{}", v),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -640,7 +642,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{v}"),
+            CalcResult::Number(v) => format!("{}", v),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {

base/src/functions/util.rs

@@ -1,10 +1,7 @@
 #[cfg(feature = "use_regex_lite")]
 use regex_lite as regex;
 
-use crate::{
+use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
-    calc_result::CalcResult, expressions::token::is_english_error_string,
-    number_format::to_excel_precision,
-};
 
 /// This test for exact match (modulo case).
 ///   * strings are not cast into bools or numbers
@@ -37,8 +34,6 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
     match (left, right) {
         (CalcResult::Number(value1), CalcResult::Number(value2)) => {
-            let value1 = to_excel_precision(*value1, 15);
-            let value2 = to_excel_precision(*value2, 15);
             if (value2 - value1).abs() < f64::EPSILON {
                 return 0;
             }
@@ -115,7 +110,7 @@ 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::Regex::new(&format!("^{reg}$"));
+        return regex::Regex::new(&format!("^{}$", reg));
     }
     regex::Regex::new(reg)
 }

base/src/language/mod.rs

@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::OnceLock};
+use std::collections::HashMap;
 
 use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
 
 #[derive(Encode, Decode, Clone)]
 pub struct Booleans {
@@ -30,17 +31,14 @@ pub struct Language {
     pub errors: Errors,
 }
 
-static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
-
 #[allow(clippy::expect_used)]
-fn get_languages() -> &'static HashMap<String, Language> {
+static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
-    LANGUAGES.get_or_init(|| {
     bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
-    })
+});
-}
 
 pub fn get_language(id: &str) -> Result<&Language, String> {
-    get_languages()
+    let language = LANGUAGES
         .get(id)
-        .ok_or_else(|| format!("Language is not supported: '{id}'"))
+        .ok_or(format!("Language is not supported: '{}'", id))?;
+    Ok(language)
 }

base/src/locale/mod.rs

@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::OnceLock};
-
 use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
+
+use std::collections::HashMap;
 
 #[derive(Encode, Decode, Clone)]
 pub struct Locale {
@@ -64,17 +65,12 @@ pub struct DecimalFormats {
     pub standard: String,
 }
 
-static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
-
 #[allow(clippy::expect_used)]
-fn get_locales() -> &'static HashMap<String, Locale> {
+static LOCALES: Lazy<HashMap<String, Locale>> =
-    LOCALES.get_or_init(|| {
+    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
-        bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
-    })
-}
 
 pub fn get_locale(id: &str) -> Result<&Locale, String> {
-    get_locales()
+    // TODO: pass the locale once we implement locales in Rust
-        .get(id)
+    let locale = LOCALES.get(id).ok_or("Invalid locale")?;
-        .ok_or_else(|| format!("Invalid locale: '{id}'"))
+    Ok(locale)
 }

base/src/model.rs

@@ -106,15 +106,15 @@ pub struct Model {
     pub(crate) shared_strings: HashMap<String, usize>,
     /// An instance of the parser
     pub(crate) parser: Parser,
-    /// The list of cells with formulas that are evaluated or being evaluated
+    /// The list of cells with formulas that are evaluated of being evaluated
     pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
     /// The locale of the model
     pub(crate) locale: Locale,
-    /// The language used
+    /// Tha language used
     pub(crate) language: Language,
     /// The timezone used to evaluate the model
     pub(crate) tz: Tz,
-    /// The view id. A view consists of a selected sheet and ranges.
+    /// The view id. A view consist of a selected sheet and ranges.
     pub(crate) view_id: u32,
 }
 
@@ -215,7 +215,7 @@ impl Model {
                 _ => CalcResult::new_error(
                     Error::ERROR,
                     cell,
-                    format!("Error with Implicit Intersection in cell {cell:?}"),
+                    format!("Error with Implicit Intersection in cell {:?}", cell),
                 ),
             },
             _ => self.evaluate_node_in_context(node, cell),
@@ -355,7 +355,7 @@ impl Model {
                         return s;
                     }
                 };
-                let result = format!("{l}{r}");
+                let result = format!("{}{}", l, r);
                 CalcResult::String(result)
             }
             OpProductKind { kind, left, right } => match kind {
@@ -375,7 +375,7 @@ impl Model {
             }
             FunctionKind { kind, args } => self.evaluate_function(kind, args, cell),
             InvalidFunctionKind { name, args: _ } => {
-                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {name}"))
+                CalcResult::new_error(Error::ERROR, cell, format!("Invalid function: {}", name))
             }
             ArrayKind(s) => CalcResult::Array(s.to_owned()),
             DefinedNameKind((name, scope, _)) => {
@@ -391,26 +391,26 @@ impl Model {
                         ParsedDefinedName::InvalidDefinedNameFormula => CalcResult::new_error(
                             Error::NAME,
                             cell,
-                            format!("Defined name \"{name}\" is not a reference."),
+                            format!("Defined name \"{}\" is not a reference.", name),
                         ),
                     }
                 } else {
                     CalcResult::new_error(
                         Error::NAME,
                         cell,
-                        format!("Defined name \"{name}\" not found."),
+                        format!("Defined name \"{}\" not found.", name),
                     )
                 }
             }
             TableNameKind(s) => CalcResult::new_error(
                 Error::NAME,
                 cell,
-                format!("table name \"{s}\" not supported."),
+                format!("table name \"{}\" not supported.", s),
             ),
             WrongVariableKind(s) => CalcResult::new_error(
                 Error::NAME,
                 cell,
-                format!("Variable name \"{s}\" not found."),
+                format!("Variable name \"{}\" not found.", s),
             ),
             CompareKind { kind, left, right } => {
                 let l = self.evaluate_node_in_context(left, cell);
@@ -487,7 +487,7 @@ impl Model {
             } => CalcResult::new_error(
                 Error::ERROR,
                 cell,
-                format!("Error parsing {formula}: {message}"),
+                format!("Error parsing {}: {}", formula, message),
             ),
             EmptyArgKind => CalcResult::EmptyArg,
             ImplicitIntersection {
@@ -500,7 +500,7 @@ impl Model {
                         None => CalcResult::new_error(
                             Error::VALUE,
                             cell,
-                            format!("Error with Implicit Intersection in cell {cell:?}"),
+                            format!("Error with Implicit Intersection in cell {:?}", cell),
                         ),
                     }
                 }
@@ -697,7 +697,7 @@ impl Model {
             worksheet.color = Some(color.to_string());
             return Ok(());
         }
-        Err(format!("Invalid color: {color}"))
+        Err(format!("Invalid color: {}", color))
     }
 
     /// Changes the visibility of a sheet
@@ -1027,7 +1027,7 @@ impl Model {
         let source_sheet_name = self
             .workbook
             .worksheet(source.sheet)
-            .map_err(|e| format!("Could not find source worksheet: {e}"))?
+            .map_err(|e| format!("Could not find source worksheet: {}", e))?
             .get_name();
         if source.sheet != area.sheet {
             return Err("Source and area are in different sheets".to_string());
@@ -1041,7 +1041,7 @@ impl Model {
         let target_sheet_name = self
             .workbook
             .worksheet(target.sheet)
-            .map_err(|e| format!("Could not find target worksheet: {e}"))?
+            .map_err(|e| format!("Could not find target worksheet: {}", e))?
             .get_name();
         if let Some(formula) = value.strip_prefix('=') {
             let cell_reference = CellReferenceRC {
@@ -1061,7 +1061,7 @@ impl Model {
                     column_delta: target.column - source.column,
                 },
             );
-            Ok(format!("={formula_str}"))
+            Ok(format!("={}", formula_str))
         } else {
             Ok(value.to_string())
         }
@@ -1538,7 +1538,7 @@ impl Model {
         // If the formula fails to parse try adding a parenthesis
         // SUM(A1:A3  => SUM(A1:A3)
         if let Node::ParseErrorKind { .. } = parsed_formula {
-            let new_parsed_formula = self.parser.parse(&format!("{formula})"), &cell_reference);
+            let new_parsed_formula = self.parser.parse(&format!("{})", formula), &cell_reference);
             match new_parsed_formula {
                 Node::ParseErrorKind { .. } => {}
                 _ => parsed_formula = new_parsed_formula,
@@ -2068,7 +2068,21 @@ impl Model {
         scope: Option<u32>,
         formula: &str,
     ) -> Result<(), String> {
-        let sheet_id = self.is_valid_defined_name(name, scope, formula)?;
+        if !is_valid_identifier(name) {
+            return Err("Invalid defined name".to_string());
+        };
+        let name_upper = name.to_uppercase();
+        let defined_names = &self.workbook.defined_names;
+        let sheet_id = match scope {
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
+            None => None,
+        };
+        // if the defined name already exist return error
+        for df in defined_names {
+            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
+                return Err("Defined name already exists".to_string());
+            }
+        }
         self.workbook.defined_names.push(DefinedName {
             name: name.to_string(),
             formula: formula.to_string(),
@@ -2079,48 +2093,6 @@ impl Model {
         Ok(())
     }
 
-    /// Validates if a defined name can be created
-    pub fn is_valid_defined_name(
-        &self,
-        name: &str,
-        scope: Option<u32>,
-        formula: &str,
-    ) -> Result<Option<u32>, String> {
-        if !is_valid_identifier(name) {
-            return Err("Name: Invalid defined name".to_string());
-        }
-        let name_upper = name.to_uppercase();
-        let defined_names = &self.workbook.defined_names;
-        let sheet_id = match scope {
-            Some(index) => match self.workbook.worksheet(index) {
-                Ok(ws) => Some(ws.sheet_id),
-                Err(_) => return Err("Scope: Invalid sheet index".to_string()),
-            },
-            None => None,
-        };
-        // if the defined name already exist return error
-        for df in defined_names {
-            if df.name.to_uppercase() == name_upper && df.sheet_id == sheet_id {
-                return Err("Name: Defined name already exists".to_string());
-            }
-        }
-
-        // Make sure the formula is valid
-        match common::ParsedReference::parse_reference_formula(
-            None,
-            formula,
-            &self.locale,
-            |name| self.get_sheet_index_by_name(name),
-        ) {
-            Ok(_) => {}
-            Err(_) => {
-                return Err("Formula: Invalid defined name formula".to_string());
-            }
-        };
-
-        Ok(sheet_id)
-    }
-
     /// Delete defined name of name and scope
     pub fn delete_defined_name(&mut self, name: &str, scope: Option<u32>) -> Result<(), String> {
         let name_upper = name.to_uppercase();
@@ -2154,7 +2126,7 @@ impl Model {
         new_formula: &str,
     ) -> Result<(), String> {
         if !is_valid_identifier(new_name) {
-            return Err("Name: Invalid defined name".to_string());
+            return Err("Invalid defined name".to_string());
         };
         let name_upper = name.to_uppercase();
         let new_name_upper = new_name.to_uppercase();
@@ -2162,28 +2134,18 @@ impl Model {
         if name_upper != new_name_upper || scope != new_scope {
             for key in self.parsed_defined_names.keys() {
                 if key.1.to_uppercase() == new_name_upper && key.0 == new_scope {
-                    return Err("Name: Defined name already exists".to_string());
+                    return Err("Defined name already exists".to_string());
                 }
             }
         }
         let defined_names = &self.workbook.defined_names;
         let sheet_id = match scope {
-            Some(index) => Some(
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
-                self.workbook
-                    .worksheet(index)
-                    .map_err(|_| "Scope: Invalid sheet index")?
-                    .sheet_id,
-            ),
             None => None,
         };
 
         let new_sheet_id = match new_scope {
-            Some(index) => Some(
+            Some(index) => Some(self.workbook.worksheet(index)?.sheet_id),
-                self.workbook
-                    .worksheet(index)
-                    .map_err(|_| "Scope: Invalid sheet index")?
-                    .sheet_id,
-            ),
             None => None,
         };
 

base/src/new_empty.rs

@@ -168,11 +168,11 @@ impl Model {
             .get_worksheet_names()
             .iter()
             .map(|s| s.to_uppercase())
-            .any(|x| x == format!("{base_name_uppercase}{index}"))
+            .any(|x| x == format!("{}{}", base_name_uppercase, index))
         {
             index += 1;
         }
-        let sheet_name = format!("{base_name}{index}");
+        let sheet_name = format!("{}{}", base_name, index);
         // Now we need a sheet_id
         let sheet_id = self.get_new_sheet_id();
         let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
@@ -192,7 +192,7 @@ impl Model {
         sheet_id: Option<u32>,
     ) -> Result<(), String> {
         if !is_valid_sheet_name(sheet_name) {
-            return Err(format!("Invalid name for a sheet: '{sheet_name}'"));
+            return Err(format!("Invalid name for a sheet: '{}'", sheet_name));
         }
         if self
             .workbook
@@ -234,7 +234,7 @@ impl Model {
         if let Some(sheet_index) = self.get_sheet_index_by_name(old_name) {
             return self.rename_sheet_by_index(sheet_index, new_name);
         }
-        Err(format!("Could not find sheet {old_name}"))
+        Err(format!("Could not find sheet {}", old_name))
     }
 
     /// Renames a sheet and updates all existing references to that sheet.
@@ -248,10 +248,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));
         }
         // Gets the new name and checks that a sheet with that index exists
         let old_name = self.workbook.worksheet(sheet_index)?.get_name();
@@ -362,14 +362,14 @@ impl Model {
         };
         let locale = match get_locale(locale_id) {
             Ok(l) => l.clone(),
-            Err(_) => return Err(format!("Invalid locale: {locale_id}")),
+            Err(_) => return Err(format!("Invalid locale: {}", locale_id)),
         };
 
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
         let dt = match DateTime::from_timestamp(seconds, 0) {
             Some(s) => s,
-            None => return Err(format!("Invalid timestamp: {milliseconds}")),
+            None => return Err(format!("Invalid timestamp: {}", milliseconds)),
         };
         // "2020-08-06T21:20:53Z
         let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
@@ -405,6 +405,7 @@ impl Model {
             },
             tables: HashMap::new(),
             views,
+            users: Vec::new(),
         };
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;

base/src/number_format.rs

@@ -112,36 +112,29 @@ pub fn to_precision(value: f64, precision: usize) -> f64 {
 /// ```
 /// This intends to be equivalent to the js: `${parseFloat(value.toPrecision(precision)})`
 /// See ([ecma](https://tc39.es/ecma262/#sec-number.prototype.toprecision)).
+/// FIXME: There has to be a better algorithm :/
 pub fn to_excel_precision_str(value: f64) -> String {
     to_precision_str(value, 15)
 }
-
-pub fn to_excel_precision(value: f64, precision: usize) -> f64 {
-    if !value.is_finite() {
-        return value;
-    }
-
-    let s = format!("{:.*e}", precision.saturating_sub(1), value);
-    s.parse::<f64>().unwrap_or(value)
-}
-
 pub fn to_precision_str(value: f64, precision: usize) -> String {
-    if !value.is_finite() {
     if value.is_infinite() {
         return "inf".to_string();
-        } else {
+    }
+    if value.is_nan() {
         return "NaN".to_string();
     }
-    }
+    let exponent = value.abs().log10().floor();
-
+    let base = value / 10.0_f64.powf(exponent);
-    let s = format!("{:.*e}", precision.saturating_sub(1), value);
+    let base = format!("{0:.1$}", base, precision - 1);
-    let parsed = s.parse::<f64>().unwrap_or(value);
+    let value = format!("{}e{}", base, exponent).parse::<f64>().unwrap_or({
-
+        // TODO: do this in a way that does not require a possible error
+        0.0
+    });
     // I would love to use the std library. There is not a speed concern here
     // problem is it doesn't do the right thing
     // Also ryu is my favorite _modern_ algorithm
     let mut buffer = ryu::Buffer::new();
-    let text = buffer.format(parsed);
+    let text = buffer.format(value);
     // The above algorithm converts 2 to 2.0 regrettably
     if let Some(stripped) = text.strip_suffix(".0") {
         return stripped.to_string();

base/src/styles.rs

@@ -154,7 +154,7 @@ impl Styles {
                 return Ok(cell_style.xf_id);
             }
         }
-        Err(format!("Style '{style_name}' not found"))
+        Err(format!("Style '{}' not found", style_name))
     }
 
     pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {

base/src/test/engineering/test_complex.rs

@@ -133,7 +133,6 @@ fn fn_imcot() {
     );
 }
 
-#[cfg_attr(target_os = "windows", ignore)]
 #[test]
 fn fn_imtan() {
     let mut model = new_empty_model();

base/src/test/mod.rs

@@ -7,9 +7,6 @@ mod test_column_width;
 mod test_criteria;
 mod test_currency;
 mod test_date_and_time;
-mod test_datedif_leap_month_end;
-mod test_days360_month_end;
-mod test_degrees_radians;
 mod test_error_propagation;
 mod test_fn_average;
 mod test_fn_averageifs;
@@ -30,7 +27,6 @@ mod test_fn_sum;
 mod test_fn_sumifs;
 mod test_fn_textbefore;
 mod test_fn_textjoin;
-mod test_fn_time;
 mod test_fn_unicode;
 mod test_frozen_rows_columns;
 mod test_general;
@@ -47,11 +43,8 @@ mod test_sheets;
 mod test_styles;
 mod test_trigonometric;
 mod test_true_false;
-mod test_weekday_return_types;
-mod test_weeknum_return_types;
 mod test_workbook;
 mod test_worksheet;
-mod test_yearfrac_basis;
 pub(crate) mod util;
 
 mod engineering;
@@ -62,23 +55,14 @@ mod test_arrays;
 mod test_escape_quotes;
 mod test_extend;
 mod test_fn_fv;
-mod test_fn_round;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_geomean;
 mod test_get_cell_content;
 mod test_implicit_intersection;
 mod test_issue_155;
-mod test_issue_483;
-mod test_ln;
-mod test_log;
-mod test_log10;
-mod test_mod_quotient;
-mod test_networkdays;
-mod test_now;
 mod test_percentage;
 mod test_set_functions_error_handling;
-mod test_sheet_names;
 mod test_today;
 mod test_types;
 mod user_model;

base/src/test/test_actions.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -508,10 +508,6 @@ fn test_move_column_right() {
     assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
     assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
     assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G1"), "1");
-    assert_eq!(model._get_text("H1"), "3");
 }
 
 #[test]
@@ -536,249 +532,5 @@ fn tets_move_column_error() {
     assert!(result.is_ok());
 }
 
-#[test]
-fn test_move_row_down() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Formulas referencing rows 3 and 4
-    model._set("E3", "=G3");
-    model._set("E4", "=G4");
-    model._set("E5", "=SUM(G3:J3)");
-    model._set("E6", "=SUM(G3:G3)");
-    model._set("E7", "=SUM(G4:G4)");
-    model.evaluate();
-
-    // Move row 3 down by one position
-    let result = model.move_row_action(0, 3, 1);
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=G3");
-    assert_eq!(model._get_formula("E4"), "=G4");
-    assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
-    assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
-    assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G4"), "-2");
-    assert_eq!(model._get_text("G3"), "");
-}
-
-#[test]
-fn test_move_row_up() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Formulas referencing rows 4 and 5
-    model._set("E4", "=G4");
-    model._set("E5", "=G5");
-    model._set("E6", "=SUM(G4:J4)");
-    model._set("E7", "=SUM(G4:G4)");
-    model._set("E8", "=SUM(G5:G5)");
-    model.evaluate();
-
-    // Move row 5 up by one position
-    let result = model.move_row_action(0, 5, -1);
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E4"), "=G4");
-    assert_eq!(model._get_formula("E5"), "=G5");
-    assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
-    assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
-    assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
-
-    // Data moved as well
-    assert_eq!(model._get_text("G4"), "");
-    assert_eq!(model._get_text("G5"), "");
-}
-
-#[test]
-fn test_move_row_error() {
-    let mut model = new_empty_model();
-    model.evaluate();
-
-    let result = model.move_row_action(0, 7, -10);
-    assert!(result.is_err());
-
-    let result = model.move_row_action(0, -7, 20);
-    assert!(result.is_err());
-
-    let result = model.move_row_action(0, LAST_ROW, 1);
-    assert!(result.is_err());
-
-    let result = model.move_row_action(0, LAST_ROW + 1, -10);
-    assert!(result.is_err());
-
-    // This works
-    let result = model.move_row_action(0, LAST_ROW, -1);
-    assert!(result.is_ok());
-}
-
-#[test]
-fn test_move_row_down_absolute_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Absolute references
-    model._set("E3", "=$G$3");
-    model._set("E4", "=$G$4");
-    model._set("E5", "=SUM($G$3:$J$3)");
-    model._set("E6", "=SUM($G$3:$G$3)");
-    model._set("E7", "=SUM($G$4:$G$4)");
-    model.evaluate();
-
-    assert!(model.move_row_action(0, 3, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$G$3");
-    assert_eq!(model._get_formula("E4"), "=$G$4");
-    assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
-    assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
-}
-
-#[test]
-fn test_move_column_right_absolute_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Absolute references
-    model._set("E3", "=$G$3");
-    model._set("E4", "=$H$3");
-    model._set("E5", "=SUM($G$3:$J$7)");
-    model._set("E6", "=SUM($G$3:$G$7)");
-    model._set("E7", "=SUM($H$3:$H$7)");
-    model.evaluate();
-
-    assert!(model.move_column_action(0, 7, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$H$3");
-    assert_eq!(model._get_formula("E4"), "=$G$3");
-    assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
-    assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
-}
-
-#[test]
-fn test_move_row_down_mixed_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    model._set("E3", "=$G3"); // absolute col, relative row
-    model._set("E4", "=$G4");
-    model._set("E5", "=SUM($G3:$J3)");
-    model._set("E6", "=SUM($G3:$G3)");
-    model._set("E7", "=SUM($G4:$G4)");
-    model._set("F3", "=H$3"); // relative col, absolute row
-    model._set("F4", "=G$3");
-    model.evaluate();
-
-    assert!(model.move_row_action(0, 3, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$G3");
-    assert_eq!(model._get_formula("E4"), "=$G4");
-    assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
-    assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
-    assert_eq!(model._get_formula("F3"), "=G$4");
-    assert_eq!(model._get_formula("F4"), "=H$4");
-}
-
-#[test]
-fn test_move_column_right_mixed_refs() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    model._set("E3", "=$G3");
-    model._set("E4", "=$H3");
-    model._set("E5", "=SUM($G3:$J7)");
-    model._set("E6", "=SUM($G3:$G7)");
-    model._set("E7", "=SUM($H3:$H7)");
-    model._set("F3", "=H$3");
-    model._set("F4", "=H$3");
-    model.evaluate();
-
-    assert!(model.move_column_action(0, 7, 1).is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("E3"), "=$H3");
-    assert_eq!(model._get_formula("E4"), "=$G3");
-    assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
-    assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
-    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
-    assert_eq!(model._get_formula("F3"), "=G$3");
-    assert_eq!(model._get_formula("F4"), "=G$3");
-}
-
-#[test]
-fn test_move_row_height() {
-    let mut model = new_empty_model();
-    let sheet = 0;
-    let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
-    // Set a custom height for row 3
-    model
-        .workbook
-        .worksheet_mut(sheet)
-        .unwrap()
-        .set_row_height(3, custom_height)
-        .unwrap();
-
-    // Record the original height of row 4 (should be the default)
-    let original_row4_height = model.get_row_height(sheet, 4).unwrap();
-
-    // Move row 3 down by one position
-    assert!(model.move_row_action(sheet, 3, 1).is_ok());
-
-    // The custom height should now be on row 4
-    assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
-
-    // Row 3 should now have the previous height of row 4
-    assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
-}
-
-/// Moving a row down by two positions should shift formulas on intermediate
-/// rows by only one (the row that gets skipped), not by the full delta ‒ this
-/// guards against the regression fixed in the RowMove displacement logic.
-#[test]
-fn test_row_move_down_two_updates_intermediate_refs_by_one() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Set up formulas to verify intermediate rows shift by 1 (not full delta).
-    model._set("E3", "=G3"); // target row
-    model._set("E4", "=G4"); // intermediate row
-    model._set("E5", "=SUM(G3:J3)");
-    model.evaluate();
-
-    // Move row 3 down by two positions (row 3 -> row 5)
-    assert!(model.move_row_action(0, 3, 2).is_ok());
-    model.evaluate();
-
-    // Assert that references for the moved row and intermediate row are correct.
-    assert_eq!(model._get_formula("E3"), "=G3");
-    assert_eq!(model._get_formula("E5"), "=G5");
-    assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
-}
-
-/// Moving a column right by two positions should shift formulas on
-/// intermediate columns by only one, ensuring the ColumnMove displacement
-/// logic handles multi-position moves correctly.
-#[test]
-fn test_column_move_right_two_updates_intermediate_refs_by_one() {
-    let mut model = new_empty_model();
-    populate_table(&mut model);
-    // Set up formulas to verify intermediate columns shift by 1 (not full delta).
-    model._set("E3", "=$G3"); // target column
-    model._set("E4", "=$H3"); // intermediate column
-    model._set("E5", "=SUM($G3:$J7)");
-    model.evaluate();
-
-    // Move column G (7) right by two positions (G -> I)
-    assert!(model.move_column_action(0, 7, 2).is_ok());
-    model.evaluate();
-
-    // Assert that references for moved and intermediate columns are correct.
-    assert_eq!(model._get_formula("E3"), "=$I3");
-    assert_eq!(model._get_formula("E4"), "=$G3");
-    assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
-}
-
 // A  B  C  D  E  F  G   H  I  J   K   L   M   N   O   P   Q   R
 // 1  2  3  4  5  6  7   8  9  10  11  12  13  14  15  16  17  18

base/src/test/test_arabic_roman

@@ -1,27 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=ARABIC()");
-    model._set("A2", "=ARABIC(V)");
-    model._set("A3", "=ARABIC(V, 2)");
-
-    model._set("A4", "=ROMAN()");
-    model._set("A5", "=ROMAN(5)");
-    model._set("A6", "=ROMAN(5, 0)");
-    model._set("A7", "=ROMAN(5, 0, 2)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"5");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"V");
-    assert_eq!(model._get_text("A6"), *"V");
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-}

base/src/test/test_combin_combina

@@ -1,27 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=COMBIN(5,2)");
-    model._set("A2", "=COMBINA(5,2)");
-    model._set("A3", "=COMBIN()");
-    model._set("A4", "=COMBINA()");
-    model._set("A5", "=COMBIN(2)");
-    model._set("A6", "=COMBINA(2)");
-    model._set("A5", "=COMBIN(1, 2, 3)");
-    model._set("A6", "=COMBINA(1, 2, 3)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"10");
-    assert_eq!(model._get_text("A2"), *"15");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#ERROR!");
-}

base/src/test/test_date_and_time.rs

@@ -6,11 +6,6 @@
 /// We can also enter examples that illustrate/document a part of the function
 use crate::{cell::CellValue, test::util::new_empty_model};
 
-// Excel uses a serial date system where Jan 1, 1900 = 1 (though it treats 1900 as a leap year)
-// Most test dates are documented inline, but we define boundary values here:
-const EXCEL_MAX_DATE: f64 = 2958465.0; // Dec 31, 9999 - used in boundary tests
-const EXCEL_INVALID_DATE: f64 = 2958466.0; // One day past max - used in error tests
-
 #[test]
 fn test_fn_date_arguments() {
     let mut model = new_empty_model();
@@ -221,380 +216,3 @@ fn test_date_early_dates() {
         Ok(CellValue::Number(61.0))
     );
 }
-#[test]
-fn test_days_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality
-    model._set("A1", "=DAYS(44570,44561)");
-    model._set("A2", "=DAYS(44561,44570)"); // Reversed order
-    model._set("A3", "=DAYS(44561,44561)");
-
-    // Edge cases
-    model._set("A4", "=DAYS(1,2)"); // Early dates
-    model._set(
-        "A5",
-        &format!("=DAYS({},{})", EXCEL_MAX_DATE, EXCEL_MAX_DATE - 1.0),
-    ); // Near max date
-
-    // Error cases - wrong argument count
-    model._set("A6", "=DAYS()");
-    model._set("A7", "=DAYS(44561)");
-    model._set("A8", "=DAYS(44561,44570,1)");
-
-    // Error cases - invalid dates
-    model._set("A9", "=DAYS(-1,44561)");
-    model._set("A10", &format!("=DAYS(44561,{EXCEL_INVALID_DATE})"));
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"9");
-    assert_eq!(model._get_text("A2"), *"-9");
-    assert_eq!(model._get_text("A3"), *"0");
-    assert_eq!(model._get_text("A4"), *"-1"); // DAYS(1,2) = 1-2 = -1
-    assert_eq!(model._get_text("A5"), *"1");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#ERROR!");
-    assert_eq!(model._get_text("A9"), *"#NUM!");
-    assert_eq!(model._get_text("A10"), *"#NUM!");
-}
-
-#[test]
-fn test_days360_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality with different basis values
-    model._set("A1", "=DAYS360(44196,44560)"); // Default basis (US 30/360)
-    model._set("A2", "=DAYS360(44196,44560,FALSE)"); // US 30/360 explicitly
-    model._set("A3", "=DAYS360(44196,44560,TRUE)"); // European 30/360
-
-    // Same date
-    model._set("A4", "=DAYS360(44561,44561)");
-    model._set("A5", "=DAYS360(44561,44561,TRUE)");
-
-    // Reverse order (negative result)
-    model._set("A6", "=DAYS360(44560,44196)");
-    model._set("A7", "=DAYS360(44560,44196,TRUE)");
-
-    // Edge cases
-    model._set("A8", "=DAYS360(1,2)");
-    model._set("A9", "=DAYS360(1,2,FALSE)");
-
-    // Error cases - wrong argument count
-    model._set("A10", "=DAYS360()");
-    model._set("A11", "=DAYS360(44561)");
-    model._set("A12", "=DAYS360(44561,44570,TRUE,1)");
-
-    // Error cases - invalid dates
-    model._set("A13", "=DAYS360(-1,44561)");
-    model._set("A14", &format!("=DAYS360(44561,{EXCEL_INVALID_DATE})"));
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"360");
-    assert_eq!(model._get_text("A2"), *"360");
-    assert_eq!(model._get_text("A3"), *"360");
-    assert_eq!(model._get_text("A4"), *"0");
-    assert_eq!(model._get_text("A5"), *"0");
-    assert_eq!(model._get_text("A6"), *"-360");
-    assert_eq!(model._get_text("A7"), *"-360");
-    assert_eq!(model._get_text("A8"), *"1");
-    assert_eq!(model._get_text("A9"), *"1");
-    assert_eq!(model._get_text("A10"), *"#ERROR!");
-    assert_eq!(model._get_text("A11"), *"#ERROR!");
-    assert_eq!(model._get_text("A12"), *"#ERROR!");
-    assert_eq!(model._get_text("A13"), *"#NUM!");
-    assert_eq!(model._get_text("A14"), *"#NUM!");
-}
-
-#[test]
-fn test_weekday_function() {
-    let mut model = new_empty_model();
-
-    // Test return_type parameter variations with one known date (Friday 44561)
-    model._set("A1", "=WEEKDAY(44561)"); // Default: Sun=1, Fri=6
-    model._set("A2", "=WEEKDAY(44561,2)"); // Mon=1, Fri=5
-    model._set("A3", "=WEEKDAY(44561,3)"); // Mon=0, Fri=4
-
-    // Test boundary days (Sun/Mon) to verify return_type logic
-    model._set("A4", "=WEEKDAY(44556,1)"); // Sunday: should be 1
-    model._set("A5", "=WEEKDAY(44556,2)"); // Sunday: should be 7
-    model._set("A6", "=WEEKDAY(44557,2)"); // Monday: should be 1
-
-    // Error cases
-    model._set("A7", "=WEEKDAY()"); // Wrong arg count
-    model._set("A8", "=WEEKDAY(44561,0)"); // Invalid return_type
-    model._set("A9", "=WEEKDAY(-1)"); // Invalid date
-
-    model.evaluate();
-
-    // Core functionality
-    assert_eq!(model._get_text("A1"), *"6"); // Friday default
-    assert_eq!(model._get_text("A2"), *"5"); // Friday Mon=1
-    assert_eq!(model._get_text("A3"), *"4"); // Friday Mon=0
-
-    // Boundary verification
-    assert_eq!(model._get_text("A4"), *"1"); // Sunday Sun=1
-    assert_eq!(model._get_text("A5"), *"7"); // Sunday Mon=1
-    assert_eq!(model._get_text("A6"), *"1"); // Monday Mon=1
-
-    // Error cases
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#VALUE!");
-    assert_eq!(model._get_text("A9"), *"#NUM!");
-}
-
-#[test]
-fn test_weeknum_function() {
-    let mut model = new_empty_model();
-
-    // Test different return_type values (1=week starts Sunday, 2=week starts Monday)
-    model._set("A1", "=WEEKNUM(44561)"); // Default return_type=1
-    model._set("A2", "=WEEKNUM(44561,1)"); // Sunday start
-    model._set("A3", "=WEEKNUM(44561,2)"); // Monday start
-
-    // Test year boundaries
-    model._set("A4", "=WEEKNUM(43831,1)"); // Jan 1, 2020 (Wednesday)
-    model._set("A5", "=WEEKNUM(43831,2)"); // Jan 1, 2020 (Wednesday)
-    model._set("A6", "=WEEKNUM(44196,1)"); // Dec 31, 2020 (Thursday)
-    model._set("A7", "=WEEKNUM(44196,2)"); // Dec 31, 2020 (Thursday)
-
-    // Test first and last weeks of year
-    model._set("A8", "=WEEKNUM(44197,1)"); // Jan 1, 2021 (Friday)
-    model._set("A9", "=WEEKNUM(44197,2)"); // Jan 1, 2021 (Friday)
-    model._set("A10", "=WEEKNUM(44561,1)"); // Dec 31, 2021 (Friday)
-    model._set("A11", "=WEEKNUM(44561,2)"); // Dec 31, 2021 (Friday)
-
-    // Error cases - wrong argument count
-    model._set("A12", "=WEEKNUM()");
-    model._set("A13", "=WEEKNUM(44561,1,1)");
-
-    // Error cases - invalid return_type
-    model._set("A14", "=WEEKNUM(44561,0)");
-    model._set("A15", "=WEEKNUM(44561,3)");
-    model._set("A16", "=WEEKNUM(44561,-1)");
-
-    // Error cases - invalid dates
-    model._set("A17", "=WEEKNUM(-1)");
-    model._set("A18", &format!("=WEEKNUM({EXCEL_INVALID_DATE})"));
-
-    model.evaluate();
-
-    // Basic functionality
-    assert_eq!(model._get_text("A1"), *"53"); // Week 53
-    assert_eq!(model._get_text("A2"), *"53"); // Week 53 (Sunday start)
-    assert_eq!(model._get_text("A3"), *"53"); // Week 53 (Monday start)
-
-    // Year boundary tests
-    assert_eq!(model._get_text("A4"), *"1"); // Jan 1, 2020 (Sunday start)
-    assert_eq!(model._get_text("A5"), *"1"); // Jan 1, 2020 (Monday start)
-    assert_eq!(model._get_text("A6"), *"53"); // Dec 31, 2020 (Sunday start)
-    assert_eq!(model._get_text("A7"), *"53"); // Dec 31, 2020 (Monday start)
-
-    // 2021 tests
-    assert_eq!(model._get_text("A8"), *"1"); // Jan 1, 2021 (Sunday start)
-    assert_eq!(model._get_text("A9"), *"1"); // Jan 1, 2021 (Monday start)
-    assert_eq!(model._get_text("A10"), *"53"); // Dec 31, 2021 (Sunday start)
-    assert_eq!(model._get_text("A11"), *"53"); // Dec 31, 2021 (Monday start)
-
-    // Error cases
-    assert_eq!(model._get_text("A12"), *"#ERROR!");
-    assert_eq!(model._get_text("A13"), *"#ERROR!");
-    assert_eq!(model._get_text("A14"), *"#VALUE!");
-    assert_eq!(model._get_text("A15"), *"#VALUE!");
-    assert_eq!(model._get_text("A16"), *"#VALUE!");
-    assert_eq!(model._get_text("A17"), *"#NUM!");
-    assert_eq!(model._get_text("A18"), *"#NUM!");
-}
-
-#[test]
-fn test_workday_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality
-    model._set("A1", "=WORKDAY(44560,1)");
-    model._set("A2", "=WORKDAY(44561,-1)");
-    model._set("A3", "=WORKDAY(44561,0)");
-    model._set("A4", "=WORKDAY(44560,5)");
-
-    // Test with holidays
-    model._set("B1", "44561");
-    model._set("A5", "=WORKDAY(44560,1,B1)"); // Should skip the holiday
-    model._set("B2", "44562");
-    model._set("B3", "44563");
-    model._set("A6", "=WORKDAY(44560,3,B1:B3)"); // Multiple holidays
-
-    // Test starting on weekend
-    model._set("A7", "=WORKDAY(44562,1)"); // Saturday start
-    model._set("A8", "=WORKDAY(44563,1)"); // Sunday start
-
-    // Test negative workdays
-    model._set("A9", "=WORKDAY(44565,-3)"); // Go backwards 3 days
-    model._set("A10", "=WORKDAY(44565,-5,B1:B3)"); // Backwards with holidays
-
-    // Edge cases
-    model._set("A11", "=WORKDAY(1,1)"); // Early date
-    model._set("A12", "=WORKDAY(100000,10)"); // Large numbers
-
-    // Error cases - wrong argument count
-    model._set("A13", "=WORKDAY()");
-    model._set("A14", "=WORKDAY(44560)");
-    model._set("A15", "=WORKDAY(44560,1,B1,B2)");
-
-    // Error cases - invalid dates
-    model._set("A16", "=WORKDAY(-1,1)");
-    model._set("A17", &format!("=WORKDAY({EXCEL_INVALID_DATE},1)"));
-
-    // Error cases - invalid holiday dates
-    model._set("B4", "-1");
-    model._set("A18", "=WORKDAY(44560,1,B4)");
-
-    model.evaluate();
-
-    // Basic functionality
-    assert_eq!(model._get_text("A1"), *"44561"); // 1 day forward
-    assert_eq!(model._get_text("A2"), *"44560"); // 1 day backward
-    assert_eq!(model._get_text("A3"), *"44561"); // 0 days
-    assert_eq!(model._get_text("A4"), *"44567"); // 5 days forward
-
-    // With holidays
-    assert_eq!(model._get_text("A5"), *"44564"); // Skip holiday, go to Monday
-    assert_eq!(model._get_text("A6"), *"44566"); // Skip multiple holidays
-
-    // Weekend starts
-    assert_eq!(model._get_text("A7"), *"44564"); // From Saturday
-    assert_eq!(model._get_text("A8"), *"44564"); // From Sunday
-
-    // Negative workdays
-    assert_eq!(model._get_text("A9"), *"44560"); // 3 days back
-    assert_eq!(model._get_text("A10"), *"44557"); // 5 days back with holidays
-
-    // Edge cases
-    assert_eq!(model._get_text("A11"), *"2"); // Early date
-    assert_eq!(model._get_text("A12"), *"100014"); // Large numbers
-
-    // Error cases
-    assert_eq!(model._get_text("A13"), *"#ERROR!");
-    assert_eq!(model._get_text("A14"), *"#ERROR!");
-    assert_eq!(model._get_text("A15"), *"#ERROR!");
-    assert_eq!(model._get_text("A16"), *"#NUM!");
-    assert_eq!(model._get_text("A17"), *"#NUM!");
-    assert_eq!(model._get_text("A18"), *"#NUM!"); // Invalid holiday
-}
-
-#[test]
-fn test_workday_intl_function() {
-    let mut model = new_empty_model();
-
-    // Test key weekend mask types
-    model._set("A1", "=WORKDAY.INTL(44560,1,1)"); // Numeric: standard (Sat-Sun)
-    model._set("A2", "=WORKDAY.INTL(44560,1,2)"); // Numeric: Sun-Mon
-    model._set("A3", "=WORKDAY.INTL(44560,1,\"0000001\")"); // String: Sunday only
-    model._set("A4", "=WORKDAY.INTL(44560,1,\"1100000\")"); // String: Mon-Tue
-
-    // Test with holidays
-    model._set("B1", "44561");
-    model._set("A5", "=WORKDAY.INTL(44560,2,1,B1)"); // Standard + holiday
-    model._set("A6", "=WORKDAY.INTL(44560,2,7,B1)"); // Fri-Sat + holiday
-
-    // Basic edge cases
-    model._set("A7", "=WORKDAY.INTL(44561,0,1)"); // Zero days
-    model._set("A8", "=WORKDAY.INTL(44565,-1,1)"); // Negative days
-
-    // Error cases
-    model._set("A9", "=WORKDAY.INTL()"); // Wrong arg count
-    model._set("A10", "=WORKDAY.INTL(44560,1,0)"); // Invalid weekend mask
-    model._set("A11", "=WORKDAY.INTL(44560,1,\"123\")"); // Invalid string mask
-    model._set("A12", "=WORKDAY.INTL(-1,1,1)"); // Invalid date
-
-    model.evaluate();
-
-    // Weekend mask functionality
-    assert_eq!(model._get_text("A1"), *"44561"); // Standard weekend
-    assert_eq!(model._get_text("A2"), *"44561"); // Sun-Mon weekend
-    assert_eq!(model._get_text("A3"), *"44561"); // Sunday only
-    assert_eq!(model._get_text("A4"), *"44561"); // Mon-Tue weekend
-
-    // With holidays
-    assert_eq!(model._get_text("A5"), *"44565"); // Skip holiday + standard weekend
-    assert_eq!(model._get_text("A6"), *"44564"); // Skip holiday + Fri-Sat weekend
-
-    // Edge cases
-    assert_eq!(model._get_text("A7"), *"44561"); // Zero days
-    assert_eq!(model._get_text("A8"), *"44564"); // Negative days
-
-    // Error cases
-    assert_eq!(model._get_text("A9"), *"#ERROR!");
-    assert_eq!(model._get_text("A10"), *"#NUM!");
-    assert_eq!(model._get_text("A11"), *"#VALUE!");
-    assert_eq!(model._get_text("A12"), *"#NUM!");
-}
-
-#[test]
-fn test_yearfrac_function() {
-    let mut model = new_empty_model();
-
-    // Test key basis values (not exhaustive - just verify parameter works)
-    model._set("A1", "=YEARFRAC(44561,44926)"); // Default (30/360)
-    model._set("A2", "=YEARFRAC(44561,44926,1)"); // Actual/actual
-    model._set("A3", "=YEARFRAC(44561,44926,4)"); // European 30/360
-
-    // Edge cases
-    model._set("A4", "=YEARFRAC(44561,44561,1)"); // Same date = 0
-    model._set("A6", "=YEARFRAC(44197,44562,1)"); // Exact year (2021)
-
-    // Error cases
-    model._set("A7", "=YEARFRAC()"); // Wrong arg count
-    model._set("A8", "=YEARFRAC(44561,44926,5)"); // Invalid basis
-    model._set("A9", "=YEARFRAC(-1,44926,1)"); // Invalid date
-
-    model.evaluate();
-
-    // Basic functionality (approximate values expected)
-    assert_eq!(model._get_text("A1"), *"1"); // About 1 year
-    assert_eq!(model._get_text("A2"), *"1"); // About 1 year
-    assert_eq!(model._get_text("A3"), *"1"); // About 1 year
-
-    // Edge cases
-    assert_eq!(model._get_text("A4"), *"0"); // Same date
-    assert_eq!(model._get_text("A6"), *"1"); // Exact year
-
-    // Error cases
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#NUM!"); // Invalid basis should return #NUM!
-    assert_eq!(model._get_text("A9"), *"#NUM!");
-}
-
-#[test]
-fn test_isoweeknum_function() {
-    let mut model = new_empty_model();
-
-    // Basic functionality
-    model._set("A1", "=ISOWEEKNUM(44563)"); // Mid-week date
-    model._set("A2", "=ISOWEEKNUM(44561)"); // Year-end date
-
-    // Key ISO week boundaries (just critical cases)
-    model._set("A3", "=ISOWEEKNUM(44197)"); // Jan 1, 2021 (Fri) -> Week 53 of 2020
-    model._set("A4", "=ISOWEEKNUM(44200)"); // Jan 4, 2021 (Mon) -> Week 1 of 2021
-    model._set("A5", "=ISOWEEKNUM(44564)"); // Jan 3, 2022 (Mon) -> Week 1 of 2022
-
-    // Error cases
-    model._set("A6", "=ISOWEEKNUM()"); // Wrong arg count
-    model._set("A7", "=ISOWEEKNUM(-1)"); // Invalid date
-
-    model.evaluate();
-
-    // Basic functionality
-    assert_eq!(model._get_text("A1"), *"52");
-    assert_eq!(model._get_text("A2"), *"52");
-
-    // ISO week boundaries
-    assert_eq!(model._get_text("A3"), *"53"); // Week 53 of previous year
-    assert_eq!(model._get_text("A4"), *"1"); // Week 1 of current year
-    assert_eq!(model._get_text("A5"), *"1"); // Week 1 of next year
-
-    // Error cases
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-    assert_eq!(model._get_text("A7"), *"#NUM!");
-}

base/src/test/test_datedif_leap_month_end.rs

@@ -1,33 +0,0 @@
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_datedif_yd_leap_year_edge_cases() {
-    let mut model = new_empty_model();
-
-    // 29 Feb 2020 → 28 Feb 2021   (should be 0 days)
-    model._set("A1", "=DATEDIF(\"29/2/2020\", \"28/2/2021\", \"YD\")");
-
-    // 29 Feb 2020 → 1 Mar 2021    (should be 1 day)
-    model._set("A2", "=DATEDIF(\"29/2/2020\", \"2021-03-01\", \"YD\")");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"0");
-    assert_eq!(model._get_text("A2"), *"1");
-}
-
-#[test]
-fn test_datedif_md_month_end_edge_cases() {
-    let mut model = new_empty_model();
-
-    // 31 Jan 2021 → 28 Feb 2021 (non-leap) => 28
-    model._set("B1", "=DATEDIF(\"31/1/2021\", \"28/2/2021\", \"MD\")");
-
-    // 31 Jan 2020 → 29 Feb 2020 (leap) => 29
-    model._set("B2", "=DATEDIF(\"31/1/2020\", \"29/2/2020\", \"MD\")");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"28");
-    assert_eq!(model._get_text("B2"), *"29");
-}

base/src/test/test_days360_month_end.rs

@@ -1,43 +0,0 @@
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_days360_month_end_us() {
-    let mut model = new_empty_model();
-
-    // 31 Jan 2021 -> 28 Feb 2021 (non-leap)
-    model._set("A1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28))");
-
-    // 31 Jan 2020 -> 28 Feb 2020 (leap year – not last day of Feb)
-    model._set("A2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,28))");
-
-    // 28 Feb 2020 -> 31 Mar 2020 (leap year span crossing month ends)
-    model._set("A3", "=DAYS360(DATE(2020,2,28),DATE(2020,3,31))");
-
-    // 30 Apr 2021 -> 31 May 2021 (end-of-month adjustment rule)
-    model._set("A4", "=DAYS360(DATE(2021,4,30),DATE(2021,5,31))");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"30");
-    assert_eq!(model._get_text("A2"), *"28");
-    assert_eq!(model._get_text("A3"), *"33");
-    assert_eq!(model._get_text("A4"), *"30");
-}
-
-#[test]
-fn test_days360_month_end_european() {
-    let mut model = new_empty_model();
-
-    // European basis = TRUE (or 1)
-    model._set("B1", "=DAYS360(DATE(2021,1,31),DATE(2021,2,28),TRUE)");
-
-    model._set("B2", "=DAYS360(DATE(2020,1,31),DATE(2020,2,29),TRUE)");
-
-    model._set("B3", "=DAYS360(DATE(2021,8,31),DATE(2021,9,30),TRUE)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("B1"), *"28");
-    assert_eq!(model._get_text("B2"), *"29");
-    assert_eq!(model._get_text("B3"), *"30");
-}

base/src/test/test_degrees_radians.rs

@@ -1,22 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn fn_degrees_radians_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=DEGREES()");
-    model._set("A2", "=RADIANS()");
-    model._set("A3", "=RADIANS(180)");
-    model._set("A4", "=RADIANS(180, 2)");
-    model._set("A5", "=DEGREES(RADIANS(180))");
-    model._set("A6", "=DEGREES(1, 2)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"3.141592654");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"180");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-}

base/src/test/test_even_odd

@@ -1,23 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=EVEN(2)");
-    model._set("A2", "=ODD(2)");
-    model._set("A3", "=EVEN()");
-    model._set("A4", "=ODD()");
-    model._set("A5", "=EVEN(1, 2)");
-    model._set("A6", "=ODD(1, 2)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"3");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-}

base/src/test/test_exp_sign.rs

@@ -1,26 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn fn_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=EXP()");
-    model._set("A2", "=SIGN()");
-
-    model._set("A3", "=EXP(0)");
-    model._set("A4", "=SIGN(-10)");
-
-    model._set("A5", "=EXP(1, 2)");
-    model._set("A6", "=SIGN(1, 2)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-
-    assert_eq!(model._get_text("A3"), *"1");
-    assert_eq!(model._get_text("A4"), *"-1");
-
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-}

base/src/test/test_fn_datevalue_datedif.rs

@@ -1,182 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-use crate::types::Cell;
-
-// Helper to evaluate a formula and return the formatted text
-fn eval_formula(formula: &str) -> String {
-    let mut model = new_empty_model();
-    model._set("A1", formula);
-    model.evaluate();
-    model._get_text("A1")
-}
-
-// Helper that evaluates a formula and returns the raw value of A1 as a Result<f64, String>
-fn eval_formula_raw_number(formula: &str) -> Result<f64, String> {
-    let mut model = new_empty_model();
-    model._set("A1", formula);
-    model.evaluate();
-    match model._get_cell("A1") {
-        Cell::NumberCell { v, .. } => Ok(*v),
-        Cell::BooleanCell { v, .. } => Ok(if *v { 1.0 } else { 0.0 }),
-        Cell::ErrorCell { ei, .. } => Err(format!("{}", ei)),
-        _ => Err(model._get_text("A1")),
-    }
-}
-
-#[test]
-fn test_datevalue_basic_numeric() {
-    // DATEVALUE should return the serial number representing the date, **not** a formatted date
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2/1/2023\")").unwrap(),
-        44958.0
-    );
-}
-
-#[test]
-fn test_datevalue_mmdd_with_leading_zero() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"02/01/2023\")").unwrap(),
-        44958.0
-    ); // 1-Feb-2023
-}
-
-#[test]
-fn test_datevalue_iso() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2023-01-02\")").unwrap(),
-        44928.0
-    );
-}
-
-#[test]
-fn test_datevalue_month_name() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2-Jan-23\")").unwrap(),
-        44928.0
-    );
-}
-
-#[test]
-fn test_datevalue_ambiguous_ddmm() {
-    // 01/02/2023 interpreted as MM/DD -> 2-Jan-2023
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"01/02/2023\")").unwrap(),
-        44929.0
-    );
-}
-
-#[test]
-fn test_datevalue_ddmm_unambiguous() {
-    // 15/01/2023 should be 15-Jan-2023 since 15 cannot be month
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"15/01/2023\")").unwrap(),
-        44941.0
-    );
-}
-
-#[test]
-fn test_datevalue_leap_day() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"29/02/2020\")").unwrap(),
-        43890.0
-    );
-}
-
-#[test]
-fn test_datevalue_year_first_text_month() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"2023/Jan/15\")").unwrap(),
-        44941.0
-    );
-}
-
-#[test]
-fn test_datevalue_mmdd_with_day_gt_12() {
-    assert_eq!(
-        eval_formula_raw_number("=DATEVALUE(\"6/15/2021\")").unwrap(),
-        44373.0
-    );
-}
-
-#[test]
-fn test_datevalue_error_conditions() {
-    let cases = [
-        "=DATEVALUE(\"31/04/2023\")",   // invalid day (Apr has 30 days)
-        "=DATEVALUE(\"13/13/2023\")",   // invalid month
-        "=DATEVALUE(\"not a date\")",   // non-date text
-    ];
-    for formula in cases {
-        let result = eval_formula(formula);
-        assert_eq!(result, *"#VALUE!", "Expected #VALUE! for {}", formula);
-    }
-}
-
-// Helper to set and evaluate a single DATEDIF call
-fn eval_datedif(unit: &str) -> String {
-    let mut model = new_empty_model();
-    let formula = format!("=DATEDIF(\"2020-01-01\", \"2021-06-15\", \"{}\")", unit);
-    model._set("A1", &formula);
-    model.evaluate();
-    model._get_text("A1")
-}
-
-#[test]
-fn test_datedif_y() {
-    assert_eq!(eval_datedif("Y"), *"1");
-}
-
-#[test]
-fn test_datedif_m() {
-    assert_eq!(eval_datedif("M"), *"17");
-}
-
-#[test]
-fn test_datedif_d() {
-    assert_eq!(eval_datedif("D"), *"531");
-}
-
-#[test]
-fn test_datedif_ym() {
-    assert_eq!(eval_datedif("YM"), *"5");
-}
-
-#[test]
-fn test_datedif_yd() {
-    assert_eq!(eval_datedif("YD"), *"165");
-}
-
-#[test]
-fn test_datedif_md() {
-    assert_eq!(eval_datedif("MD"), *"14");
-}
-
-#[test]
-fn test_datedif_edge_and_error_cases() {
-    let mut model = new_empty_model();
-    // Leap-year spanning
-    model._set("A1", "=DATEDIF(\"28/2/2020\", \"1/3/2020\", \"D\")");
-    // End date before start date => #NUM!
-    model._set("A2", "=DATEDIF(\"1/2/2021\", \"1/1/2021\", \"D\")");
-    // Invalid unit => #VALUE!
-    model._set("A3", "=DATEDIF(\"1/1/2020\", \"1/1/2021\", \"Z\")");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
-    assert_eq!(model._get_text("A3"), *"#VALUE!");
-}
-
-#[test]
-fn test_datedif_mixed_case_unit() {
-    assert_eq!(eval_datedif("yD"), *"165"); // mixed-case should work
-}
-
-#[test]
-fn test_datedif_error_propagation() {
-    // Invalid date in arguments should propagate #VALUE!
-    let mut model = new_empty_model();
-    model._set("A1", "=DATEDIF(\"bad\", \"bad\", \"Y\")");
-    model.evaluate();
-    assert_eq!(model._get_text("A1"), *"#VALUE!");
-}

base/src/test/test_fn_datevalue_timevalue.rs

@@ -1,24 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn datevalue_timevalue_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=DATEVALUE()");
-    model._set("A2", "=TIMEVALUE()");
-    model._set("A3", "=DATEVALUE("2000-01-01")")
-    model._set("A4", "=TIMEVALUE("12:00:00")")
-    model._set("A5", "=DATEVALUE(1,2)");
-    model._set("A6", "=TIMEVALUE(1,2)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"36526");
-    assert_eq!(model._get_text("A4"), *"0.5");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-}
-
-

base/src/test/test_fn_or_xor.rs

@@ -174,7 +174,7 @@ fn fn_or_xor_no_arguments() {
         println!("Testing function: {func}");
 
         let mut model = new_empty_model();
-        model._set("A1", &format!("={func}()"));
+        model._set("A1", &format!("={}()", func));
         model.evaluate();
         assert_eq!(model._get_text("A1"), *"#ERROR!");
     }

base/src/test/test_fn_round.rs

@@ -1,15 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn fn_round_approximation() {
-    let mut model = new_empty_model();
-    model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
-    model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"0.0063");
-    assert_eq!(model._get_text("A2"), *"0.00625");
-}

base/src/test/test_fn_time.rs

@@ -1,520 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-// Helper constants for common time values with detailed documentation
-const MIDNIGHT: &str = "0"; // 00:00:00 = 0/24 = 0
-const NOON: &str = "0.5"; // 12:00:00 = 12/24 = 0.5
-const TIME_14_30: &str = "0.604166667"; // 14:30:00 = 14.5/24 ≈ 0.604166667
-const TIME_14_30_45: &str = "0.6046875"; // 14:30:45 = 14.5125/24 = 0.6046875
-const TIME_14_30_59: &str = "0.604849537"; // 14:30:59 (from floored fractional inputs)
-const TIME_23_59_59: &str = "0.999988426"; // 23:59:59 = 23.99972.../24 ≈ 0.999988426
-
-// Excel documentation test values with explanations
-const TIME_2_24_AM: &str = "0.1"; // 2:24 AM = 2.4/24 = 0.1
-const TIME_2_PM: &str = "0.583333333"; // 2:00 PM = 14/24 ≈ 0.583333333
-const TIME_6_45_PM: &str = "0.78125"; // 6:45 PM = 18.75/24 = 0.78125
-const TIME_6_35_AM: &str = "0.274305556"; // 6:35 AM = 6.583333.../24 ≈ 0.274305556
-const TIME_2_30_AM: &str = "0.104166667"; // 2:30 AM = 2.5/24 ≈ 0.104166667
-const TIME_1_AM: &str = "0.041666667"; // 1:00 AM = 1/24 ≈ 0.041666667
-const TIME_9_PM: &str = "0.875"; // 9:00 PM = 21/24 = 0.875
-const TIME_2_AM: &str = "0.083333333"; // 2:00 AM = 2/24 ≈ 0.083333333
-                                       // Additional helper: 1-second past midnight (00:00:01)
-const TIME_00_00_01: &str = "0.000011574"; // 1 second = 1/86400 ≈ 0.000011574
-
-/// Helper function to set up and evaluate a model with time expressions
-fn test_time_expressions(expressions: &[(&str, &str)]) -> crate::model::Model {
-    let mut model = new_empty_model();
-    for (cell, formula) in expressions {
-        model._set(cell, formula);
-    }
-    model.evaluate();
-    model
-}
-
-/// Helper function to test component extraction for a given time value
-/// Returns (hour, minute, second) as strings
-fn test_component_extraction(time_value: &str) -> (String, String, String) {
-    let model = test_time_expressions(&[
-        ("A1", &format!("=HOUR({time_value})")),
-        ("B1", &format!("=MINUTE({time_value})")),
-        ("C1", &format!("=SECOND({time_value})")),
-    ]);
-    (
-        model._get_text("A1").to_string(),
-        model._get_text("B1").to_string(),
-        model._get_text("C1").to_string(),
-    )
-}
-
-#[test]
-fn test_excel_timevalue_compatibility() {
-    // Test cases based on Excel's official documentation and examples
-    let model = test_time_expressions(&[
-        // Excel documentation examples
-        ("A1", "=TIMEVALUE(\"2:24 AM\")"), // Should be 0.1
-        ("A2", "=TIMEVALUE(\"2 PM\")"),    // Should be 0.583333... (14/24)
-        ("A3", "=TIMEVALUE(\"6:45 PM\")"), // Should be 0.78125 (18.75/24)
-        ("A4", "=TIMEVALUE(\"18:45\")"),   // Same as above, 24-hour format
-        // Date-time format (date should be ignored)
-        ("B1", "=TIMEVALUE(\"22-Aug-2011 6:35 AM\")"), // Should be ~0.2743
-        ("B2", "=TIMEVALUE(\"2023-01-01 14:30:00\")"), // Should be 0.604166667
-        // Edge cases that Excel should support
-        ("C1", "=TIMEVALUE(\"12:00 AM\")"),    // Midnight: 0
-        ("C2", "=TIMEVALUE(\"12:00 PM\")"),    // Noon: 0.5
-        ("C3", "=TIMEVALUE(\"11:59:59 PM\")"), // Almost midnight: 0.999988426
-        // Single digit variations
-        ("D1", "=TIMEVALUE(\"1 AM\")"),  // 1:00 AM
-        ("D2", "=TIMEVALUE(\"9 PM\")"),  // 9:00 PM
-        ("D3", "=TIMEVALUE(\"12 AM\")"), // Midnight
-        ("D4", "=TIMEVALUE(\"12 PM\")"), // Noon
-    ]);
-
-    // Excel documentation examples - verify exact values
-    assert_eq!(model._get_text("A1"), *TIME_2_24_AM); // 2:24 AM
-    assert_eq!(model._get_text("A2"), *TIME_2_PM); // 2 PM = 14:00
-    assert_eq!(model._get_text("A3"), *TIME_6_45_PM); // 6:45 PM = 18:45
-    assert_eq!(model._get_text("A4"), *TIME_6_45_PM); // 18:45 (24-hour)
-
-    // Date-time formats (date ignored, extract time only)
-    assert_eq!(model._get_text("B1"), *TIME_6_35_AM); // 6:35 AM ≈ 0.2743
-    assert_eq!(model._get_text("B2"), *TIME_14_30); // 14:30:00
-
-    // Edge cases
-    assert_eq!(model._get_text("C1"), *MIDNIGHT); // 12:00 AM = 00:00
-    assert_eq!(model._get_text("C2"), *NOON); // 12:00 PM = 12:00
-    assert_eq!(model._get_text("C3"), *TIME_23_59_59); // 11:59:59 PM
-
-    // Single digit hours
-    assert_eq!(model._get_text("D1"), *TIME_1_AM); // 1:00 AM
-    assert_eq!(model._get_text("D2"), *TIME_9_PM); // 9:00 PM = 21:00
-    assert_eq!(model._get_text("D3"), *MIDNIGHT); // 12 AM = 00:00
-    assert_eq!(model._get_text("D4"), *NOON); // 12 PM = 12:00
-}
-
-#[test]
-fn test_time_function_basic_cases() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIME(0,0,0)"),    // Midnight
-        ("A2", "=TIME(12,0,0)"),   // Noon
-        ("A3", "=TIME(14,30,0)"),  // 2:30 PM
-        ("A4", "=TIME(23,59,59)"), // Max time
-    ]);
-
-    assert_eq!(model._get_text("A1"), *MIDNIGHT);
-    assert_eq!(model._get_text("A2"), *NOON);
-    assert_eq!(model._get_text("A3"), *TIME_14_30);
-    assert_eq!(model._get_text("A4"), *TIME_23_59_59);
-}
-
-#[test]
-fn test_time_function_normalization() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIME(25,0,0)"),         // Hours > 24 wrap around
-        ("A2", "=TIME(48,0,0)"),         // 48 hours = 0 (2 full days)
-        ("A3", "=TIME(0,90,0)"),         // 90 minutes = 1.5 hours
-        ("A4", "=TIME(0,0,90)"),         // 90 seconds = 1.5 minutes
-        ("A5", "=TIME(14.9,30.9,59.9)"), // Fractional inputs floored to 14:30:59
-    ]);
-
-    assert_eq!(model._get_text("A1"), *TIME_1_AM); // 1:00:00
-    assert_eq!(model._get_text("A2"), *MIDNIGHT); // 0:00:00
-    assert_eq!(model._get_text("A3"), *"0.0625"); // 1:30:00
-    assert_eq!(model._get_text("A4"), *"0.001041667"); // 0:01:30
-    assert_eq!(model._get_text("A5"), *TIME_14_30_59); // 14:30:59 (floored)
-}
-
-#[test]
-fn test_time_function_precision_edge_cases() {
-    let model = test_time_expressions(&[
-        // High precision fractional seconds
-        ("A1", "=TIME(14,30,45.999)"), // Fractional seconds should be floored
-        ("A2", "=SECOND(TIME(14,30,45.999))"), // Should extract 45, not 46
-        // Very large normalization values
-        ("B1", "=TIME(999,999,999)"), // Extreme normalization test
-        ("B2", "=HOUR(999.5)"),       // Multiple days, extract hour from fractional part
-        ("B3", "=MINUTE(999.75)"),    // Multiple days, extract minute
-        // Boundary conditions at rollover points
-        ("C1", "=TIME(24,60,60)"), // Should normalize to next day (00:01:00)
-        ("C2", "=HOUR(0.999999999)"), // Almost 24 hours should be 23
-        ("C3", "=MINUTE(0.999999999)"), // Almost 24 hours, extract minutes
-        ("C4", "=SECOND(0.999999999)"), // Almost 24 hours, extract seconds
-        // Precision at boundaries
-        ("D1", "=TIME(23,59,59.999)"), // Very close to midnight
-        ("D2", "=TIME(0,0,0.001)"),    // Just after midnight
-    ]);
-
-    // Fractional seconds are floored
-    assert_eq!(model._get_text("A2"), *"45"); // 45.999 floored to 45
-
-    // Multiple days should work with rem_euclid
-    assert_eq!(model._get_text("B2"), *"12"); // 999.5 days, hour = 12 (noon)
-
-    // Boundary normalization
-    assert_eq!(model._get_text("C1"), *"0.042361111"); // 24:60:60 = 01:01:00 (normalized)
-    assert_eq!(model._get_text("C2"), *"23"); // Almost 24 hours = 23:xx:xx
-
-    // High precision should be handled correctly
-    let result_d1 = model._get_text("D1").parse::<f64>().unwrap();
-    assert!(result_d1 < 1.0 && result_d1 > 0.999); // Very close to but less than 1.0
-}
-
-#[test]
-fn test_time_function_errors() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIME()"),          // Wrong arg count
-        ("A2", "=TIME(12)"),        // Wrong arg count
-        ("A3", "=TIME(12,30,0,0)"), // Wrong arg count
-        ("B1", "=TIME(-1,0,0)"),    // Negative hour
-        ("B2", "=TIME(0,-1,0)"),    // Negative minute
-        ("B3", "=TIME(0,0,-1)"),    // Negative second
-    ]);
-
-    // Wrong argument count
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-
-    // Negative values should return #NUM! error
-    assert_eq!(model._get_text("B1"), *"#NUM!");
-    assert_eq!(model._get_text("B2"), *"#NUM!");
-    assert_eq!(model._get_text("B3"), *"#NUM!");
-}
-
-#[test]
-fn test_timevalue_function_formats() {
-    let model = test_time_expressions(&[
-        // Basic formats
-        ("A1", "=TIMEVALUE(\"14:30\")"),
-        ("A2", "=TIMEVALUE(\"14:30:45\")"),
-        ("A3", "=TIMEVALUE(\"00:00:00\")"),
-        // AM/PM formats
-        ("B1", "=TIMEVALUE(\"2:30 PM\")"),
-        ("B2", "=TIMEVALUE(\"2:30 AM\")"),
-        ("B3", "=TIMEVALUE(\"12:00 PM\")"), // Noon
-        ("B4", "=TIMEVALUE(\"12:00 AM\")"), // Midnight
-        // Single hour with AM/PM (now supported!)
-        ("B5", "=TIMEVALUE(\"2 PM\")"),
-        ("B6", "=TIMEVALUE(\"2 AM\")"),
-        // Date-time formats (extract time only)
-        ("C1", "=TIMEVALUE(\"2023-01-01 14:30:00\")"),
-        ("C2", "=TIMEVALUE(\"2023-01-01T14:30:00\")"),
-        // Whitespace handling
-        ("D1", "=TIMEVALUE(\" 14:30 \")"),
-    ]);
-
-    // Basic formats
-    assert_eq!(model._get_text("A1"), *TIME_14_30);
-    assert_eq!(model._get_text("A2"), *TIME_14_30_45);
-    assert_eq!(model._get_text("A3"), *MIDNIGHT);
-
-    // AM/PM formats
-    assert_eq!(model._get_text("B1"), *TIME_14_30); // 2:30 PM = 14:30
-    assert_eq!(model._get_text("B2"), *TIME_2_30_AM); // 2:30 AM
-    assert_eq!(model._get_text("B3"), *NOON); // 12:00 PM = noon
-    assert_eq!(model._get_text("B4"), *MIDNIGHT); // 12:00 AM = midnight
-
-    // Single hour AM/PM formats (now supported!)
-    assert_eq!(model._get_text("B5"), *TIME_2_PM); // 2 PM = 14:00
-    assert_eq!(model._get_text("B6"), *TIME_2_AM); // 2 AM = 02:00
-
-    // Date-time formats
-    assert_eq!(model._get_text("C1"), *TIME_14_30);
-    assert_eq!(model._get_text("C2"), *TIME_14_30);
-
-    // Whitespace
-    assert_eq!(model._get_text("D1"), *TIME_14_30);
-}
-
-#[test]
-fn test_timevalue_function_errors() {
-    let model = test_time_expressions(&[
-        ("A1", "=TIMEVALUE()"),                 // Wrong arg count
-        ("A2", "=TIMEVALUE(\"14:30\", \"x\")"), // Wrong arg count
-        ("B1", "=TIMEVALUE(\"invalid\")"),      // Invalid format
-        ("B2", "=TIMEVALUE(\"25:00\")"),        // Invalid hour
-        ("B3", "=TIMEVALUE(\"14:70\")"),        // Invalid minute
-        ("B4", "=TIMEVALUE(\"\")"),             // Empty string
-        ("B5", "=TIMEVALUE(\"2PM\")"),          // Missing space (still unsupported)
-    ]);
-
-    // Wrong argument count should return #ERROR!
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-
-    // Invalid formats should return #VALUE!
-    assert_eq!(model._get_text("B1"), *"#VALUE!");
-    assert_eq!(model._get_text("B2"), *"#VALUE!");
-    assert_eq!(model._get_text("B3"), *"#VALUE!");
-    assert_eq!(model._get_text("B4"), *"#VALUE!");
-    assert_eq!(model._get_text("B5"), *"#VALUE!"); // "2PM" no space - not supported
-}
-
-#[test]
-fn test_time_component_extraction_comprehensive() {
-    // Test component extraction using helper function for consistency
-
-    // Test basic time values
-    let test_cases = [
-        (MIDNIGHT, ("0", "0", "0")),         // 00:00:00
-        (NOON, ("12", "0", "0")),            // 12:00:00
-        (TIME_14_30, ("14", "30", "0")),     // 14:30:00
-        (TIME_23_59_59, ("23", "59", "59")), // 23:59:59
-    ];
-
-    for (time_value, expected) in test_cases {
-        let (hour, minute, second) = test_component_extraction(time_value);
-        assert_eq!(hour, expected.0, "Hour mismatch for {time_value}");
-        assert_eq!(minute, expected.1, "Minute mismatch for {time_value}");
-        assert_eq!(second, expected.2, "Second mismatch for {time_value}");
-    }
-
-    // Test multiple days (extract from fractional part)
-    let (hour, minute, second) = test_component_extraction("1.5"); // Day 2, 12:00
-    assert_eq!(
-        (hour, minute, second),
-        ("12".to_string(), "0".to_string(), "0".to_string())
-    );
-
-    let (hour, minute, second) = test_component_extraction("100.604166667"); // Day 101, 14:30
-    assert_eq!(
-        (hour, minute, second),
-        ("14".to_string(), "30".to_string(), "0".to_string())
-    );
-
-    // Test precision at boundaries
-    let (hour, _, _) = test_component_extraction("0.041666666"); // Just under 1:00 AM
-    assert_eq!(hour, "0");
-
-    let (hour, _, _) = test_component_extraction("0.041666667"); // Exactly 1:00 AM
-    assert_eq!(hour, "1");
-
-    let (hour, _, _) = test_component_extraction("0.041666668"); // Just over 1:00 AM
-    assert_eq!(hour, "1");
-
-    // Test very large day values
-    let (hour, minute, second) = test_component_extraction("1000000.25"); // Million days + 6 hours
-    assert_eq!(
-        (hour, minute, second),
-        ("6".to_string(), "0".to_string(), "0".to_string())
-    );
-}
-
-#[test]
-fn test_time_component_function_errors() {
-    let model = test_time_expressions(&[
-        // Wrong argument counts
-        ("A1", "=HOUR()"),       // No arguments
-        ("A2", "=MINUTE()"),     // No arguments
-        ("A3", "=SECOND()"),     // No arguments
-        ("A4", "=HOUR(1, 2)"),   // Too many arguments
-        ("A5", "=MINUTE(1, 2)"), // Too many arguments
-        ("A6", "=SECOND(1, 2)"), // Too many arguments
-        // Negative values should return #NUM!
-        ("B1", "=HOUR(-0.5)"),        // Negative value
-        ("B2", "=MINUTE(-1)"),        // Negative value
-        ("B3", "=SECOND(-1)"),        // Negative value
-        ("B4", "=HOUR(-0.000001)"),   // Slightly negative
-        ("B5", "=MINUTE(-0.000001)"), // Slightly negative
-        ("B6", "=SECOND(-0.000001)"), // Slightly negative
-    ]);
-
-    // Wrong argument count should return #ERROR!
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-
-    // Negative values should return #NUM!
-    assert_eq!(model._get_text("B1"), *"#NUM!");
-    assert_eq!(model._get_text("B2"), *"#NUM!");
-    assert_eq!(model._get_text("B3"), *"#NUM!");
-    assert_eq!(model._get_text("B4"), *"#NUM!");
-    assert_eq!(model._get_text("B5"), *"#NUM!");
-    assert_eq!(model._get_text("B6"), *"#NUM!");
-}
-
-#[test]
-fn test_time_functions_integration() {
-    // Test how TIME, TIMEVALUE and component extraction functions work together
-    let model = test_time_expressions(&[
-        // Create times with both functions
-        ("A1", "=TIME(14,30,45)"),
-        ("A2", "=TIMEVALUE(\"14:30:45\")"),
-        // Extract components from TIME function results
-        ("B1", "=HOUR(A1)"),
-        ("B2", "=MINUTE(A1)"),
-        ("B3", "=SECOND(A1)"),
-        // Extract components from TIMEVALUE function results
-        ("C1", "=HOUR(A2)"),
-        ("C2", "=MINUTE(A2)"),
-        ("C3", "=SECOND(A2)"),
-        // Test additional TIME variations
-        ("D1", "=TIME(14,0,0)"), // 14:00:00
-        ("E1", "=HOUR(D1)"),     // Extract hour from 14:00:00
-        ("E2", "=MINUTE(D1)"),   // Extract minute from 14:00:00
-        ("E3", "=SECOND(D1)"),   // Extract second from 14:00:00
-    ]);
-
-    // TIME and TIMEVALUE should produce equivalent results
-    assert_eq!(model._get_text("A1"), model._get_text("A2"));
-
-    // Extracting components should work consistently
-    assert_eq!(model._get_text("B1"), *"14");
-    assert_eq!(model._get_text("B2"), *"30");
-    assert_eq!(model._get_text("B3"), *"45");
-    assert_eq!(model._get_text("C1"), *"14");
-    assert_eq!(model._get_text("C2"), *"30");
-    assert_eq!(model._get_text("C3"), *"45");
-
-    // Components from TIME(14,0,0)
-    assert_eq!(model._get_text("E1"), *"14");
-    assert_eq!(model._get_text("E2"), *"0");
-    assert_eq!(model._get_text("E3"), *"0");
-}
-
-#[test]
-fn test_time_function_extreme_values() {
-    // Test missing edge cases: very large fractional inputs
-    let model = test_time_expressions(&[
-        // Extremely large fractional values to TIME function
-        ("A1", "=TIME(999999.9, 999999.9, 999999.9)"), // Very large fractional inputs
-        ("A2", "=TIME(1e6, 1e6, 1e6)"),                // Scientific notation inputs
-        ("A3", "=TIME(0.000001, 0.000001, 0.000001)"), // Very small fractional inputs
-        // Large day values for component extraction (stress test)
-        ("B1", "=HOUR(999999.999)"), // Almost a million days
-        ("B2", "=MINUTE(999999.999)"),
-        ("B3", "=SECOND(999999.999)"),
-        // Edge case: exactly 1.0 (should be midnight of next day)
-        ("C1", "=HOUR(1.0)"),
-        ("C2", "=MINUTE(1.0)"),
-        ("C3", "=SECOND(1.0)"),
-        // Very high precision values
-        ("D1", "=HOUR(0.999999999999)"), // Almost exactly 24:00:00
-        ("D2", "=MINUTE(0.999999999999)"),
-        ("D3", "=SECOND(0.999999999999)"),
-    ]);
-
-    // Large fractional inputs should be floored and normalized
-    let result_a1 = model._get_text("A1").parse::<f64>().unwrap();
-    assert!(
-        (0.0..1.0).contains(&result_a1),
-        "Result should be valid time fraction"
-    );
-
-    // Component extraction should work with very large values
-    let hour_b1 = model._get_text("B1").parse::<i32>().unwrap();
-    assert!((0..=23).contains(&hour_b1), "Hour should be 0-23");
-
-    // Exactly 1.0 should be midnight (start of next day)
-    assert_eq!(model._get_text("C1"), *"0");
-    assert_eq!(model._get_text("C2"), *"0");
-    assert_eq!(model._get_text("C3"), *"0");
-
-    // Very high precision should still extract valid components
-    let hour_d1 = model._get_text("D1").parse::<i32>().unwrap();
-    assert!((0..=23).contains(&hour_d1), "Hour should be 0-23");
-}
-
-#[test]
-fn test_timevalue_malformed_but_parseable() {
-    // Test missing edge case: malformed but potentially parseable strings
-    let model = test_time_expressions(&[
-        // Test various malformed but potentially parseable time strings
-        ("A1", "=TIMEVALUE(\"14:30:00.123\")"), // Milliseconds (might be truncated)
-        ("A2", "=TIMEVALUE(\"14:30:00.999\")"), // High precision milliseconds
-        ("A3", "=TIMEVALUE(\"02:30:00\")"),     // Leading zero hours
-        ("A4", "=TIMEVALUE(\"2:05:00\")"),      // Single digit hour, zero-padded minute
-        // Boundary cases for AM/PM parsing
-        ("B1", "=TIMEVALUE(\"11:59:59 PM\")"), // Just before midnight
-        ("B2", "=TIMEVALUE(\"12:00:01 AM\")"), // Just after midnight
-        ("B3", "=TIMEVALUE(\"12:00:01 PM\")"), // Just after noon
-        ("B4", "=TIMEVALUE(\"11:59:59 AM\")"), // Just before noon
-        // Test various date-time combinations
-        ("C1", "=TIMEVALUE(\"2023-12-31T23:59:59\")"), // ISO format at year end
-        ("C2", "=TIMEVALUE(\"2023-01-01 00:00:01\")"), // New year, just after midnight
-        // Test potential edge cases that might still be parseable
-        ("D1", "=TIMEVALUE(\"24:00:00\")"), // Should error (invalid hour)
-        ("D2", "=TIMEVALUE(\"23:60:00\")"), // Should error (invalid minute)
-        ("D3", "=TIMEVALUE(\"23:59:60\")"), // Should error (invalid second)
-    ]);
-
-    // Milliseconds are not supported, should return a #VALUE! error like Excel
-    assert_eq!(model._get_text("A1"), *"#VALUE!");
-    assert_eq!(model._get_text("A2"), *"#VALUE!");
-
-    // Leading zeros should work fine
-    assert_eq!(model._get_text("A3"), *TIME_2_30_AM); // 02:30:00 should parse as 2:30:00
-
-    // AM/PM boundary cases should work
-    let result_b1 = model._get_text("B1").parse::<f64>().unwrap();
-    assert!(
-        result_b1 > 0.99 && result_b1 < 1.0,
-        "11:59:59 PM should be very close to 1.0"
-    );
-
-    let result_b2 = model._get_text("B2").parse::<f64>().unwrap();
-    assert!(
-        result_b2 > 0.0 && result_b2 < 0.01,
-        "12:00:01 AM should be very close to 0.0"
-    );
-
-    // ISO 8601 format with "T" separator should be parsed correctly
-    assert_eq!(model._get_text("C1"), *TIME_23_59_59); // 23:59:59 → almost midnight
-    assert_eq!(model._get_text("C2"), *TIME_00_00_01); // 00:00:01 → one second past midnight
-
-    // Time parser normalizes edge cases to midnight (Excel compatibility)
-    assert_eq!(model._get_text("D1"), *"0"); // 24:00:00 = midnight of next day
-    assert_eq!(model._get_text("D2"), *"0"); // 23:60:00 normalizes to 24:00:00 = midnight
-    assert_eq!(model._get_text("D3"), *"0"); // 23:59:60 normalizes to 24:00:00 = midnight
-}
-
-#[test]
-fn test_performance_stress_with_extreme_values() {
-    // Test performance/stress cases with extreme values
-    let model = test_time_expressions(&[
-        // Very large numbers that should still work
-        ("A1", "=TIME(2147483647, 0, 0)"), // Max i32 hours
-        ("A2", "=TIME(0, 2147483647, 0)"), // Max i32 minutes
-        ("A3", "=TIME(0, 0, 2147483647)"), // Max i32 seconds
-        // Component extraction with extreme day values
-        ("B1", "=HOUR(1e15)"), // Very large day number
-        ("B2", "=MINUTE(1e15)"),
-        ("B3", "=SECOND(1e15)"),
-        // Edge of floating point precision
-        ("C1", "=HOUR(1.7976931348623157e+308)"), // Near max f64
-        ("C2", "=HOUR(2.2250738585072014e-308)"), // Near min positive f64
-        // Multiple TIME function calls with large values
-        ("D1", "=TIME(1000000, 1000000, 1000000)"), // Large normalized values
-        ("D2", "=HOUR(D1)"),                        // Extract from large TIME result
-        ("D3", "=MINUTE(D1)"),
-        ("D4", "=SECOND(D1)"),
-    ]);
-
-    // All results should be valid (not errors) even with extreme inputs
-    for cell in ["A1", "A2", "A3", "B1", "B2", "B3", "D1", "D2", "D3", "D4"] {
-        let result = model._get_text(cell);
-        assert!(
-            result != *"#ERROR!" && result != *"#NUM!" && result != *"#VALUE!",
-            "Cell {cell} should not error with extreme values: {result}",
-        );
-    }
-
-    // Results should be mathematically valid
-    let hour_b1 = model._get_text("B1").parse::<i32>().unwrap();
-    let minute_b2 = model._get_text("B2").parse::<i32>().unwrap();
-    let second_b3 = model._get_text("B3").parse::<i32>().unwrap();
-
-    assert!((0..=23).contains(&hour_b1));
-    assert!((0..=59).contains(&minute_b2));
-    assert!((0..=59).contains(&second_b3));
-
-    // TIME function results should be valid time fractions
-    let time_d1 = model._get_text("D1").parse::<f64>().unwrap();
-    assert!(
-        (0.0..1.0).contains(&time_d1),
-        "TIME result should be valid fraction"
-    );
-}

base/src/test/test_issue_483.rs

@@ -1,13 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn issue_155() {
-    let mut model = new_empty_model();
-    model._set("A1", "123");
-    model._set("D2", "=-(A1^1.22)");
-    model.evaluate();
-
-    assert_eq!(model._get_formula("D2"), "=-(A1^1.22)".to_string());
-}

base/src/test/test_ln.rs

@@ -1,17 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LN(100)");
-    model._set("A2", "=LN()");
-    model._set("A3", "=LN(100, 10)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"4.605170186");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-}

base/src/test/test_log.rs

@@ -1,19 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG(100)");
-    model._set("A2", "=LOG()");
-    model._set("A3", "=LOG(10000, 10)");
-    model._set("A4", "=LOG(100, 10, 1)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"4");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-}

base/src/test/test_log10.rs

@@ -1,35 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG10(100)");
-    model._set("A2", "=LOG10()");
-    model._set("A3", "=LOG10(100, 10)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"2");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-}
-
-#[test]
-fn cell_and_function() {
-    let mut model = new_empty_model();
-    model._set("A1", "=LOG10");
-
-    model.evaluate();
-
-    // This is the cell LOG10
-    assert_eq!(model._get_text("A1"), *"0");
-
-    model._set("LOG10", "1000");
-    model._set("A2", "=LOG10(LOG10)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"1000");
-    assert_eq!(model._get_text("A2"), *"3");
-}

base/src/test/test_mod_quotient.rs

@@ -1,22 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=MOD(5,2)");
-    model._set("A2", "=MOD()");
-    model._set("A3", "=MOD(5, 2, 1)");
-    model._set("A4", "=QUOTIENT(5, 2)");
-    model._set("A5", "=QUOTIENT()");
-    model._set("A6", "=QUOTIENT(5, 2, 1)");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"1");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-    assert_eq!(model._get_text("A4"), *"2");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-}

base/src/test/test_mround_trunc_int

@@ -1,40 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=MROUND()");
-    model._set("A2", "=MROUND(10)");
-    model._set("A3", "=MROUND(10, 3)");
-    model._set("A4", "=MROUND(10, 3, 1)");
-
-    model._set("A5", "=TRUNC()");
-    model._set("A6", "=TRUNC(10)");
-    model._set("A7", "=TRUNC(10.22, 1)");
-    model._set("A8", "=TRUNC(10, 3, 1)");
-
-    model._set("A9", "=INT()");
-    model._set("A10", "=INT(10.22)");
-    model._set("A11", "=INT(10.22, 1)");
-    model._set("A12", "=INT(10.22, 1, 2)");
-
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"9");
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-    assert_eq!(model._get_text("A7"), *"10.2");
-    assert_eq!(model._get_text("A8"), *"#ERROR!");
-
-    assert_eq!(model._get_text("A9"), *"#ERROR!");
-    assert_eq!(model._get_text("A10"), *"10");
-    assert_eq!(model._get_text("A11"), *"#ERROR!");
-    assert_eq!(model._get_text("A12"), *"#ERROR!");
-}

base/src/test/test_networkdays.rs

@@ -1,347 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-// Test data: Jan 1-10, 2023 week
-const JAN_1_2023: i32 = 44927; // Sunday
-const JAN_2_2023: i32 = 44928; // Monday
-const JAN_6_2023: i32 = 44932; // Friday
-const JAN_9_2023: i32 = 44935; // Monday
-const JAN_10_2023: i32 = 44936; // Tuesday
-
-#[test]
-fn networkdays_calculates_weekdays_excluding_weekends() {
-    let mut model = new_empty_model();
-
-    model._set("A1", &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023})"));
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "7",
-        "Should count 7 weekdays in 10-day span"
-    );
-}
-
-#[test]
-fn networkdays_handles_reverse_date_order() {
-    let mut model = new_empty_model();
-
-    model._set("A1", &format!("=NETWORKDAYS({JAN_10_2023},{JAN_1_2023})"));
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "-7",
-        "Reversed dates should return negative count"
-    );
-}
-
-#[test]
-fn networkdays_excludes_holidays_from_weekdays() {
-    let mut model = new_empty_model();
-
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},{JAN_9_2023})"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "6",
-        "Should exclude Monday holiday from 7 weekdays"
-    );
-}
-
-#[test]
-fn networkdays_handles_same_start_end_date() {
-    let mut model = new_empty_model();
-
-    model._set("A1", &format!("=NETWORKDAYS({JAN_9_2023},{JAN_9_2023})"));
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "1",
-        "Same weekday date should count as 1 workday"
-    );
-}
-
-#[test]
-fn networkdays_accepts_holiday_ranges() {
-    let mut model = new_empty_model();
-
-    model._set("B1", &JAN_2_2023.to_string());
-    model._set("B2", &JAN_6_2023.to_string());
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},B1:B2)"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "5",
-        "Should exclude 2 holidays from 7 weekdays"
-    );
-}
-
-#[test]
-fn networkdays_intl_uses_standard_weekend_by_default() {
-    let mut model = new_empty_model();
-
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023})"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "7",
-        "Default should be Saturday-Sunday weekend"
-    );
-}
-
-#[test]
-fn networkdays_intl_supports_numeric_weekend_patterns() {
-    let mut model = new_empty_model();
-
-    // Pattern 2 = Sunday-Monday weekend
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},2)"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "6",
-        "Sunday-Monday weekend should give 6 workdays"
-    );
-}
-
-#[test]
-fn networkdays_intl_supports_single_day_weekends() {
-    let mut model = new_empty_model();
-
-    // Pattern 11 = Sunday only weekend
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},11)"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "8",
-        "Sunday-only weekend should give 8 workdays"
-    );
-}
-
-#[test]
-fn networkdays_intl_supports_string_weekend_patterns() {
-    let mut model = new_empty_model();
-
-    // "0000110" = Friday-Saturday weekend
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},\"0000110\")"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "8",
-        "Friday-Saturday weekend should give 8 workdays"
-    );
-}
-
-#[test]
-fn networkdays_intl_no_weekends_counts_all_days() {
-    let mut model = new_empty_model();
-
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},\"0000000\")"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "10",
-        "No weekends should count all 10 days"
-    );
-}
-
-#[test]
-fn networkdays_intl_combines_custom_weekends_with_holidays() {
-    let mut model = new_empty_model();
-
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS.INTL({JAN_1_2023},{JAN_10_2023},\"0000110\",{JAN_9_2023})"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "7",
-        "Should exclude both weekend and holiday"
-    );
-}
-
-#[test]
-fn networkdays_validates_argument_count() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=NETWORKDAYS()");
-    model._set("A2", "=NETWORKDAYS(1,2,3,4)");
-    model._set("A3", "=NETWORKDAYS.INTL()");
-    model._set("A4", "=NETWORKDAYS.INTL(1,2,3,4,5)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), "#ERROR!");
-    assert_eq!(model._get_text("A2"), "#ERROR!");
-    assert_eq!(model._get_text("A3"), "#ERROR!");
-    assert_eq!(model._get_text("A4"), "#ERROR!");
-}
-
-#[test]
-fn networkdays_rejects_invalid_dates() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=NETWORKDAYS(-1,100)");
-    model._set("A2", "=NETWORKDAYS(1,3000000)");
-    model._set("A3", "=NETWORKDAYS(\"text\",100)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), "#NUM!");
-    assert_eq!(model._get_text("A2"), "#NUM!");
-    assert_eq!(model._get_text("A3"), "#VALUE!");
-}
-
-#[test]
-fn networkdays_intl_rejects_invalid_weekend_patterns() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=NETWORKDAYS.INTL(1,10,99)");
-    model._set("A2", "=NETWORKDAYS.INTL(1,10,\"111110\")");
-    model._set("A3", "=NETWORKDAYS.INTL(1,10,\"11111000\")");
-    model._set("A4", "=NETWORKDAYS.INTL(1,10,\"1111102\")");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), "#NUM!");
-    assert_eq!(model._get_text("A2"), "#VALUE!");
-    assert_eq!(model._get_text("A3"), "#VALUE!");
-    assert_eq!(model._get_text("A4"), "#VALUE!");
-}
-
-#[test]
-fn networkdays_rejects_invalid_holidays() {
-    let mut model = new_empty_model();
-
-    model._set("B1", "invalid");
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},B1)"),
-    );
-    model._set(
-        "A2",
-        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},-1)"),
-    );
-
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "#VALUE!",
-        "Should reject non-numeric holidays"
-    );
-    assert_eq!(
-        model._get_text("A2"),
-        "#NUM!",
-        "Should reject out-of-range holidays"
-    );
-}
-
-#[test]
-fn networkdays_handles_weekend_only_periods() {
-    let mut model = new_empty_model();
-
-    let saturday = JAN_1_2023 - 1;
-    model._set("A1", &format!("=NETWORKDAYS({saturday},{JAN_1_2023})"));
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "0",
-        "Weekend-only period should count 0 workdays"
-    );
-}
-
-#[test]
-fn networkdays_ignores_holidays_outside_date_range() {
-    let mut model = new_empty_model();
-
-    let future_holiday = JAN_10_2023 + 100;
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},{future_holiday})"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "7",
-        "Out-of-range holidays should be ignored"
-    );
-}
-
-#[test]
-fn networkdays_handles_empty_holiday_ranges() {
-    let mut model = new_empty_model();
-
-    model._set(
-        "A1",
-        &format!("=NETWORKDAYS({JAN_1_2023},{JAN_10_2023},B1:B3)"),
-    );
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "7",
-        "Empty holiday range should be treated as no holidays"
-    );
-}
-
-#[test]
-fn networkdays_handles_minimum_valid_dates() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=NETWORKDAYS(1,7)");
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "5",
-        "Should handle earliest Excel dates correctly"
-    );
-}
-
-#[test]
-fn networkdays_handles_large_date_ranges_efficiently() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=NETWORKDAYS(1,365)");
-    model.evaluate();
-
-    assert!(
-        !model._get_text("A1").starts_with('#'),
-        "Large ranges should not error"
-    );
-}

base/src/test/test_now.rs

@@ -1,30 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{mock_time, test::util::new_empty_model};
-
-// 14:44 20 Mar 2023 Berlin
-const TIMESTAMP_2023: i64 = 1679319865208;
-
-#[test]
-fn arguments() {
-    let mut model = new_empty_model();
-
-    model._set("A1", "=NOW(1)");
-    model.evaluate();
-
-    assert_eq!(
-        model._get_text("A1"),
-        "#ERROR!",
-        "NOW should not accept arguments"
-    );
-}
-
-#[test]
-fn returns_date_time() {
-    mock_time::set_mock_time(TIMESTAMP_2023);
-    let mut model = new_empty_model();
-    model._set("A1", "=NOW()");
-    model.evaluate();
-    let text = model._get_text("A1");
-    assert_eq!(text, *"20/03/2023 13:44:25");
-}

base/src/test/test_number_format.rs

@@ -8,15 +8,6 @@ fn test_simple_format() {
     assert_eq!(formatted.text, "2.3".to_string());
 }
 
-#[test]
-fn test_maximum_zeros() {
-    let formatted = format_number(1.0 / 3.0, "#,##0.0000000000000000000", "en");
-    assert_eq!(formatted.text, "0.3333333333333330000".to_string());
-
-    let formatted = format_number(1234.0 + 1.0 / 3.0, "#,##0.0000000000000000000", "en");
-    assert_eq!(formatted.text, "1,234.3333333333300000000".to_string());
-}
-
 #[test]
 #[ignore = "not yet implemented"]
 fn test_wrong_locale() {

base/src/test/test_sheet_names.rs

@@ -1,16 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn sheet_number_name() {
-    let mut model = new_empty_model();
-    model.new_sheet();
-    model._set("A1", "7");
-    model._set("A2", "=Sheet2!C3");
-    model.evaluate();
-    model.rename_sheet("Sheet2", "2024").unwrap();
-    model.evaluate();
-    assert_eq!(model.workbook.get_worksheet_names(), ["Sheet1", "2024"]);
-    assert_eq!(model._get_text("A2"), "0");
-}

base/src/test/test_styles.rs

@@ -62,17 +62,3 @@ fn test_create_named_style() {
     let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
 }
-
-#[test]
-fn empty_models_have_two_fills() {
-    let model = new_empty_model();
-    assert_eq!(model.workbook.styles.fills.len(), 2);
-    assert_eq!(
-        model.workbook.styles.fills[0].pattern_type,
-        "none".to_string()
-    );
-    assert_eq!(
-        model.workbook.styles.fills[1].pattern_type,
-        "gray125".to_string()
-    );
-}

base/src/test/test_today.rs

@@ -33,8 +33,7 @@ fn now_basic_utc() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"20/03/2023");
-    // 45005.572511574
+    assert_eq!(model._get_text("A2"), *"45005.572511574");
-    assert_eq!(model._get_text("A2"), *"20/03/2023 13:44:25");
 }
 
 #[test]
@@ -47,5 +46,5 @@ fn now_basic_europe_berlin() {
 
     assert_eq!(model._get_text("A1"), *"20/03/2023");
     // This is UTC + 1 hour: 45005.572511574 + 1/24
-    assert_eq!(model._get_text("A2"), *"20/03/2023 14:44:25");
+    assert_eq!(model._get_text("A2"), *"45005.614178241");
 }

base/src/test/test_trigonometric.rs

@@ -96,14 +96,3 @@ fn test_fn_tan_pi2() {
     // This is consistent with IEEE 754 but inconsistent with Excel
     assert_eq!(model._get_text("A1"), *"1.63312E+16");
 }
-
-#[test]
-fn test_trigonometric_identity() {
-    let mut model = new_empty_model();
-    model._set("A1", "=COTH(1)*CSCH(1)");
-    model._set("A2", "=COSH(1)/(SINH(1))^2");
-    model._set("A3", "=A1=A2");
-    model.evaluate();
-
-    assert_eq!(model._get_text("A3"), *"TRUE");
-}

base/src/test/test_trigonometric_reciprocals.rs

@@ -1,53 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::test::util::new_empty_model;
-
-#[test]
-fn fn_arguments() {
-    let mut model = new_empty_model();
-    model._set("A1", "=CSC()");
-    model._set("A2", "=SEC()");
-    model._set("A3", "=COT()");
-
-    model._set("A4", "=CSCH()");
-    model._set("A5", "=SECH()");
-    model._set("A6", "=COTH()");
-
-    model._set("A7", "=ACOT()");
-    model._set("A8", "=ACOTH()");
-
-    model._set("B1", "=CSC(1, 2)");
-    model._set("B2", "=SEC(1, 2)");
-    model._set("B3", "=COT(1, 2)");
-
-    model._set("B4", "=CSCH(1, 2)");
-    model._set("B5", "=SECH(1, 2)");
-    model._set("B6", "=COTH(1, 2)");
-
-    model._set("B7", "=ACOT(1, 2)");
-    model._set("B8", "=ACOTH(1, 2)");
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"#ERROR!");
-    assert_eq!(model._get_text("A2"), *"#ERROR!");
-    assert_eq!(model._get_text("A3"), *"#ERROR!");
-
-    assert_eq!(model._get_text("A4"), *"#ERROR!");
-    assert_eq!(model._get_text("A5"), *"#ERROR!");
-    assert_eq!(model._get_text("A6"), *"#ERROR!");
-
-    assert_eq!(model._get_text("A7"), *"#ERROR!");
-    assert_eq!(model._get_text("A8"), *"#ERROR!");
-
-    assert_eq!(model._get_text("B1"), *"#ERROR!");
-    assert_eq!(model._get_text("B2"), *"#ERROR!");
-    assert_eq!(model._get_text("B3"), *"#ERROR!");
-
-    assert_eq!(model._get_text("B4"), *"#ERROR!");
-    assert_eq!(model._get_text("B5"), *"#ERROR!");
-    assert_eq!(model._get_text("B6"), *"#ERROR!");
-
-    assert_eq!(model._get_text("B7"), *"#ERROR!");
-    assert_eq!(model._get_text("B8"), *"#ERROR!");
-}

base/src/test/test_weekday_return_types.rs

@@ -1,26 +0,0 @@
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_weekday_return_types_11_to_17() {
-    let mut model = new_empty_model();
-
-    // Test date: 44561 corresponds to a Friday (2021-12-31). We verify the
-    // numeric result for each custom week start defined by return_type 11-17.
-    model._set("A1", "=WEEKDAY(44561,11)"); // Monday start
-    model._set("A2", "=WEEKDAY(44561,12)"); // Tuesday start
-    model._set("A3", "=WEEKDAY(44561,13)"); // Wednesday start
-    model._set("A4", "=WEEKDAY(44561,14)"); // Thursday start
-    model._set("A5", "=WEEKDAY(44561,15)"); // Friday start
-    model._set("A6", "=WEEKDAY(44561,16)"); // Saturday start
-    model._set("A7", "=WEEKDAY(44561,17)"); // Sunday start
-
-    model.evaluate();
-
-    assert_eq!(model._get_text("A1"), *"5"); // Mon=1 .. Sun=7 ⇒ Fri=5
-    assert_eq!(model._get_text("A2"), *"4"); // Tue start ⇒ Fri=4
-    assert_eq!(model._get_text("A3"), *"3"); // Wed start ⇒ Fri=3
-    assert_eq!(model._get_text("A4"), *"2"); // Thu start ⇒ Fri=2
-    assert_eq!(model._get_text("A5"), *"1"); // Fri start ⇒ Fri=1
-    assert_eq!(model._get_text("A6"), *"7"); // Sat start ⇒ Fri=7
-    assert_eq!(model._get_text("A7"), *"6"); // Sun start ⇒ Fri=6
-}

base/src/test/test_weeknum_return_types.rs

@@ -1,31 +0,0 @@
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_weeknum_return_types_11_to_17_and_21() {
-    let mut model = new_empty_model();
-
-    // Date 44561 -> 2021-12-31 (Friday). Previously verified as week 53 (Sunday/Monday start).
-    // We verify that custom week-start codes 11-17 all map to week 53 and ISO variant (21) maps to 52.
-    let formulas = [
-        ("A1", "=WEEKNUM(44561,11)"),
-        ("A2", "=WEEKNUM(44561,12)"),
-        ("A3", "=WEEKNUM(44561,13)"),
-        ("A4", "=WEEKNUM(44561,14)"),
-        ("A5", "=WEEKNUM(44561,15)"),
-        ("A6", "=WEEKNUM(44561,16)"),
-        ("A7", "=WEEKNUM(44561,17)"),
-        ("A8", "=WEEKNUM(44561,21)"), // ISO week numbering
-    ];
-    for (cell, formula) in formulas {
-        model._set(cell, formula);
-    }
-
-    model.evaluate();
-
-    // All 11-17 variations should yield 53
-    for cell in ["A1", "A2", "A3", "A4", "A5", "A6", "A7"] {
-        assert_eq!(model._get_text(cell), *"53", "{cell} should be 53");
-    }
-    // ISO week (return_type 21)
-    assert_eq!(model._get_text("A8"), *"52");
-}

base/src/test/test_yearfrac_basis.rs

@@ -1,60 +0,0 @@
-#![allow(clippy::panic)]
-use crate::{cell::CellValue, test::util::new_empty_model};
-
-#[test]
-fn test_yearfrac_basis_2_actual_360() {
-    let mut model = new_empty_model();
-
-    // Non-leap span of exactly 360 days should result in 1.0
-    model._set("A1", "=YEARFRAC(44561,44921,2)");
-
-    // Leap-year span of 366 days: Jan 1 2020 → Jan 1 2021
-    model._set("A2", "=YEARFRAC(43831,44197,2)");
-
-    // Reverse order should yield negative value
-    model._set("A3", "=YEARFRAC(44921,44561,2)");
-
-    model.evaluate();
-
-    // 360/360
-    assert_eq!(model._get_text("A1"), *"1");
-
-    // 366/360 ≈ 1.0166666667 (tolerance 1e-10)
-    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!A2") {
-        assert!((v - 1.016_666_666_7).abs() < 1e-10);
-    } else {
-        panic!("Expected numeric value in A2");
-    }
-
-    // always positive A1
-    assert_eq!(model._get_text("A3"), *"1");
-}
-
-#[test]
-fn test_yearfrac_basis_3_actual_365() {
-    let mut model = new_empty_model();
-
-    // Non-leap span of exactly 365 days should result in 1.0
-    model._set("B1", "=YEARFRAC(44561,44926,3)");
-
-    // Leap-year span of 366 days
-    model._set("B2", "=YEARFRAC(43831,44197,3)");
-
-    // Same date should be 0
-    model._set("B3", "=YEARFRAC(44561,44561,3)");
-
-    model.evaluate();
-
-    // 365/365
-    assert_eq!(model._get_text("B1"), *"1");
-
-    // 366/365 ≈ 1.002739726 (tolerance 1e-10)
-    if let Ok(CellValue::Number(v)) = model.get_cell_value_by_ref("Sheet1!B2") {
-        assert!((v - 1.002_739_726).abs() < 1e-10);
-    } else {
-        panic!("Expected numeric value in B2");
-    }
-
-    // Same date
-    assert_eq!(model._get_text("B3"), *"0");
-}

base/src/test/user_model/mod.rs

@@ -1,7 +1,6 @@
 mod test_add_delete_sheets;
 mod test_autofill_columns;
 mod test_autofill_rows;
-mod test_batch_row_column_diff;
 mod test_border;
 mod test_clear_cells;
 mod test_column_style;
@@ -12,8 +11,6 @@ mod test_evaluation;
 mod test_general;
 mod test_grid_lines;
 mod test_keyboard_navigation;
-mod test_last_empty_cell;
-mod test_multi_row_column;
 mod test_on_area_selection;
 mod test_on_expand_selected_range;
 mod test_on_paste_styles;

base/src/test/user_model/test_batch_row_column_diff.rs

@@ -1,675 +0,0 @@
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::panic)]
-
-use bitcode::decode;
-
-use crate::{
-    constants::{LAST_COLUMN, LAST_ROW},
-    test::util::new_empty_model,
-    user_model::history::{Diff, QueueDiffs},
-    UserModel,
-};
-
-fn last_diff_list(model: &mut UserModel) -> Vec<Diff> {
-    let bytes = model.flush_send_queue();
-    let queue: Vec<QueueDiffs> = decode(&bytes).unwrap();
-    // Get the last operation's diff list
-    queue.last().unwrap().list.clone()
-}
-
-#[test]
-fn diff_invariant_insert_rows() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    assert!(model.insert_rows(0, 5, 3).is_ok());
-
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertRows {
-            sheet: 0,
-            row: 5,
-            count: 3
-        }
-    ));
-}
-
-#[test]
-fn diff_invariant_insert_columns() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    assert!(model.insert_columns(0, 2, 4).is_ok());
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertColumns {
-            sheet: 0,
-            column: 2,
-            count: 4
-        }
-    ));
-}
-
-#[test]
-fn undo_redo_after_batch_delete() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Place values that will shift.
-    model.set_user_input(0, 20, 1, "A").unwrap();
-    model.set_user_input(0, 1, 20, "B").unwrap();
-
-    // Fill some of the rows we are about to delete for testing
-    for r in 10..15 {
-        model.set_user_input(0, r, 1, "tmp").unwrap();
-    }
-
-    // Delete rows 10..14 and columns 5..8
-    assert!(model.delete_rows(0, 10, 5).is_ok());
-    assert!(model.delete_columns(0, 5, 4).is_ok());
-
-    // Verify shift
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
-
-    // Undo
-    model.undo().unwrap(); // columns
-    model.undo().unwrap(); // rows
-    assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "A");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 20).unwrap(), "B");
-
-    // Redo
-    model.redo().unwrap(); // rows
-    model.redo().unwrap(); // columns
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
-}
-
-#[test]
-fn diff_order_delete_rows() {
-    // Verifies that delete diffs are generated with all data preserved
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Populate rows to delete
-    for r in 5..10 {
-        model.set_user_input(0, r, 1, &r.to_string()).unwrap();
-    }
-
-    assert!(model.delete_rows(0, 5, 5).is_ok());
-
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-
-    // Should have one bulk diff with all the row data
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 5);
-            assert_eq!(*count, 5);
-            assert_eq!(old_data.len(), 5);
-            // Verify the data was collected for each row
-            for (i, row_data) in old_data.iter().enumerate() {
-                let _expected_value = (5 + i).to_string();
-                assert!(row_data.data.contains_key(&1));
-            }
-        }
-        _ => panic!("Unexpected diff variant"),
-    }
-}
-
-#[test]
-fn batch_operations_with_formulas() {
-    // Verifies formulas update correctly after batch ops
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    model.set_user_input(0, 1, 1, "10").unwrap();
-    model.set_user_input(0, 5, 1, "=A1*2").unwrap(); // Will become A3 after insert
-
-    assert!(model.insert_rows(0, 2, 2).is_ok());
-
-    // Formula should now reference A1 (unchanged) but be in row 7
-    assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "20");
-    assert_eq!(model.get_cell_content(0, 7, 1).unwrap(), "=A1*2");
-
-    // Undo and verify formula is back at original position
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "20");
-}
-
-#[test]
-fn edge_case_single_operation() {
-    // Single row/column operations should still work correctly
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    assert!(model.insert_rows(0, 1, 1).is_ok());
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-
-    assert!(model.insert_columns(0, 1, 1).is_ok());
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-}
-
-#[test]
-fn delete_empty_rows() {
-    // Delete multiple empty rows and verify behavior
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set data in rows 1 and 10, leaving rows 5-8 empty
-    model.set_user_input(0, 1, 1, "Before").unwrap();
-    model.set_user_input(0, 10, 1, "After").unwrap();
-
-    // Delete empty rows 5-8
-    assert!(model.delete_rows(0, 5, 4).is_ok());
-
-    // Verify shift
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
-
-    // Verify diffs now use bulk operation
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 5);
-            assert_eq!(*count, 4);
-            assert_eq!(old_data.len(), 4);
-            // All rows should be empty
-            for row_data in old_data {
-                assert!(row_data.data.is_empty());
-            }
-        }
-        _ => panic!("Unexpected diff variant"),
-    }
-
-    // Undo/redo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
-}
-
-#[test]
-fn delete_mixed_empty_and_filled_rows() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Alternating filled and empty rows
-    model.set_user_input(0, 5, 1, "Row5").unwrap();
-    model.set_user_input(0, 7, 1, "Row7").unwrap();
-    model.set_user_input(0, 9, 1, "Row9").unwrap();
-    model.set_user_input(0, 10, 1, "After").unwrap();
-
-    assert!(model.delete_rows(0, 5, 5).is_ok());
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "After");
-
-    // Verify mix of empty and filled row diffs
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 5);
-            assert_eq!(*count, 5);
-            assert_eq!(old_data.len(), 5);
-
-            // Count filled rows (should be 3: rows 5, 7, 9)
-            let filled_count = old_data
-                .iter()
-                .filter(|row_data| !row_data.data.is_empty())
-                .count();
-            assert_eq!(filled_count, 3);
-        }
-        _ => panic!("Unexpected diff variant"),
-    }
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
-    assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "Row7");
-    assert_eq!(model.get_formatted_cell_value(0, 9, 1).unwrap(), "Row9");
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
-}
-
-#[test]
-fn bulk_insert_rows_undo_redo() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up initial data
-    model.set_user_input(0, 1, 1, "A1").unwrap();
-    model.set_user_input(0, 2, 1, "A2").unwrap();
-    model.set_user_input(0, 5, 1, "A5").unwrap();
-
-    // Insert 3 rows at position 3
-    assert!(model.insert_rows(0, 3, 3).is_ok());
-
-    // Verify data has shifted
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 2, 1).unwrap(), "A2");
-    assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // A5 moved to A8
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertRows {
-            sheet: 0,
-            row: 3,
-            count: 3
-        }
-    ));
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "A5"); // Back to original position
-
-    // Redo
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // Shifted again
-}
-
-#[test]
-fn bulk_insert_columns_undo_redo() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up initial data
-    model.set_user_input(0, 1, 1, "A1").unwrap();
-    model.set_user_input(0, 1, 2, "B1").unwrap();
-    model.set_user_input(0, 1, 5, "E1").unwrap();
-
-    // Insert 3 columns at position 3
-    assert!(model.insert_columns(0, 3, 3).is_ok());
-
-    // Verify data has shifted
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "B1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // E1 moved to H1
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertColumns {
-            sheet: 0,
-            column: 3,
-            count: 3
-        }
-    ));
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1"); // Back to original position
-
-    // Redo
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // Shifted again
-}
-
-#[test]
-fn bulk_delete_rows_round_trip() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data with styles
-    model.set_user_input(0, 3, 1, "Row3").unwrap();
-    model.set_user_input(0, 4, 1, "Row4").unwrap();
-    model.set_user_input(0, 5, 1, "Row5").unwrap();
-    model.set_user_input(0, 6, 1, "Row6").unwrap();
-    model.set_user_input(0, 7, 1, "After").unwrap();
-
-    // Set some row heights to verify they're preserved
-    model.set_rows_height(0, 4, 4, 30.0).unwrap();
-    model.set_rows_height(0, 5, 5, 40.0).unwrap();
-
-    // Delete rows 3-6
-    assert!(model.delete_rows(0, 3, 4).is_ok());
-
-    // Verify deletion
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteRows {
-            sheet,
-            row,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*row, 3);
-            assert_eq!(*count, 4);
-            assert_eq!(old_data.len(), 4);
-            // Verify data was preserved
-            assert!(old_data[0].data.contains_key(&1)); // Row3
-            assert!(old_data[1].data.contains_key(&1)); // Row4
-            assert!(old_data[2].data.contains_key(&1)); // Row5
-            assert!(old_data[3].data.contains_key(&1)); // Row6
-        }
-        _ => panic!("Expected DeleteRows diff"),
-    }
-
-    // Undo - should restore all data and row heights
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
-    assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "After");
-    assert_eq!(model.get_row_height(0, 4).unwrap(), 30.0);
-    assert_eq!(model.get_row_height(0, 5).unwrap(), 40.0);
-
-    // Redo - should delete again
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
-
-    // Final undo to verify round-trip
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
-    assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
-}
-
-#[test]
-fn bulk_delete_columns_round_trip() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data with styles
-    model.set_user_input(0, 1, 3, "C1").unwrap();
-    model.set_user_input(0, 1, 4, "D1").unwrap();
-    model.set_user_input(0, 1, 5, "E1").unwrap();
-    model.set_user_input(0, 1, 6, "F1").unwrap();
-    model.set_user_input(0, 1, 7, "After").unwrap();
-
-    // Set some column widths to verify they're preserved
-    model.set_columns_width(0, 4, 4, 100.0).unwrap();
-    model.set_columns_width(0, 5, 5, 120.0).unwrap();
-
-    // Delete columns 3-6
-    assert!(model.delete_columns(0, 3, 4).is_ok());
-
-    // Verify deletion
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
-
-    // Check diff structure
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    match &list[0] {
-        Diff::DeleteColumns {
-            sheet,
-            column,
-            count,
-            old_data,
-        } => {
-            assert_eq!(*sheet, 0);
-            assert_eq!(*column, 3);
-            assert_eq!(*count, 4);
-            assert_eq!(old_data.len(), 4);
-            // Verify data was preserved
-            assert!(old_data[0].data.contains_key(&1)); // C1
-            assert!(old_data[1].data.contains_key(&1)); // D1
-            assert!(old_data[2].data.contains_key(&1)); // E1
-            assert!(old_data[3].data.contains_key(&1)); // F1
-        }
-        _ => panic!("Expected DeleteColumns diff"),
-    }
-
-    // Undo - should restore all data and column widths
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 7).unwrap(), "After");
-    assert_eq!(model.get_column_width(0, 4).unwrap(), 100.0);
-    assert_eq!(model.get_column_width(0, 5).unwrap(), 120.0);
-
-    // Redo - should delete again
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
-
-    // Final undo to verify round-trip
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
-    assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
-}
-
-#[test]
-fn complex_bulk_operations_sequence() {
-    // Test a complex sequence of bulk operations
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Initial setup
-    model.set_user_input(0, 1, 1, "A1").unwrap();
-    model.set_user_input(0, 2, 2, "B2").unwrap();
-    model.set_user_input(0, 3, 3, "C3").unwrap();
-
-    // Operation 1: Insert 2 rows at position 2
-    model.insert_rows(0, 2, 2).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2"); // B2 moved down
-    assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3"); // C3 moved down
-
-    // Operation 2: Insert 2 columns at position 2
-    model.insert_columns(0, 2, 2).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
-    assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2"); // B2 moved right
-    assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3"); // C3 moved right
-
-    // Operation 3: Delete the inserted rows
-    model.delete_rows(0, 2, 2).unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
-
-    // Undo all operations
-    model.undo().unwrap(); // Undo delete rows
-    assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3");
-
-    model.undo().unwrap(); // Undo insert columns
-    assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3");
-
-    model.undo().unwrap(); // Undo insert rows
-    assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 3, 3).unwrap(), "C3");
-
-    // Redo all operations
-    model.redo().unwrap(); // Redo insert rows
-    model.redo().unwrap(); // Redo insert columns
-    model.redo().unwrap(); // Redo delete rows
-    assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
-    assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
-}
-
-#[test]
-fn bulk_operations_with_formulas_update() {
-    // Test that formulas update correctly with bulk operations
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data and formulas
-    model.set_user_input(0, 1, 1, "10").unwrap();
-    model.set_user_input(0, 5, 1, "20").unwrap();
-    model.set_user_input(0, 10, 1, "=A1+A5").unwrap(); // Formula referencing A1 and A5
-
-    // Insert 3 rows at position 3
-    model.insert_rows(0, 3, 3).unwrap();
-
-    // Formula should update to reference the shifted cells
-    assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "30"); // Formula moved down
-    assert_eq!(model.get_cell_content(0, 13, 1).unwrap(), "=A1+A8"); // A5 became A8
-
-    // Undo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "30");
-    assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1+A5");
-
-    // Now test column insertion
-    model.set_user_input(0, 1, 5, "20").unwrap(); // Add value in E1
-    model.set_user_input(0, 1, 10, "=A1+E1").unwrap();
-    model.insert_columns(0, 3, 2).unwrap();
-
-    assert_eq!(model.get_formatted_cell_value(0, 1, 12).unwrap(), "30"); // Formula moved right
-    assert_eq!(model.get_cell_content(0, 1, 12).unwrap(), "=A1+G1"); // E1 became G1
-}
-
-#[test]
-fn bulk_delete_with_styles() {
-    // Test that cell and row/column styles are preserved
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Set up data with various styles
-    for r in 5..10 {
-        model.set_user_input(0, r, 1, &format!("Row{r}")).unwrap();
-        model.set_rows_height(0, r, r, (r * 10) as f64).unwrap();
-    }
-
-    // Delete and verify style preservation
-    model.delete_rows(0, 5, 5).unwrap();
-
-    // Undo should restore all styles
-    model.undo().unwrap();
-    for r in 5..10 {
-        assert_eq!(
-            model.get_formatted_cell_value(0, r, 1).unwrap(),
-            format!("Row{r}")
-        );
-        assert_eq!(model.get_row_height(0, r).unwrap(), (r * 10) as f64);
-    }
-}
-
-#[test]
-fn bulk_operations_large_count() {
-    // Test operations with large counts
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Insert a large number of rows
-    model.set_user_input(0, 1, 1, "Before").unwrap();
-    model.set_user_input(0, 100, 1, "After").unwrap();
-
-    assert!(model.insert_rows(0, 50, 100).is_ok());
-
-    // Verify shift
-    assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
-    assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After"); // Moved by 100
-
-    // Check diff
-    let list = last_diff_list(&mut model);
-    assert_eq!(list.len(), 1);
-    assert!(matches!(
-        &list[0],
-        Diff::InsertRows {
-            sheet: 0,
-            row: 50,
-            count: 100
-        }
-    ));
-
-    // Undo and redo
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 100, 1).unwrap(), "After");
-
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After");
-}
-
-#[test]
-fn bulk_operations_error_cases() {
-    // Test error conditions
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Negative count should fail
-    assert!(model.insert_rows(0, 1, -5).is_err());
-    assert!(model.insert_columns(0, 1, -5).is_err());
-    assert!(model.delete_rows(0, 1, -5).is_err());
-    assert!(model.delete_columns(0, 1, -5).is_err());
-
-    // Zero count should fail
-    assert!(model.insert_rows(0, 1, 0).is_err());
-    assert!(model.insert_columns(0, 1, 0).is_err());
-    assert!(model.delete_rows(0, 1, 0).is_err());
-    assert!(model.delete_columns(0, 1, 0).is_err());
-
-    // Out of bounds operations should fail
-    assert!(model.delete_rows(0, LAST_ROW - 5, 10).is_err());
-    assert!(model.delete_columns(0, LAST_COLUMN - 5, 10).is_err());
-}
-
-#[test]
-fn bulk_diff_serialization() {
-    // Test that bulk diffs can be serialized/deserialized correctly
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Create some data
-    model.set_user_input(0, 1, 1, "Test").unwrap();
-    model.insert_rows(0, 2, 3).unwrap();
-
-    // Flush and get the serialized diffs
-    let bytes = model.flush_send_queue();
-
-    // Create a new model and apply the diffs
-    let base2 = new_empty_model();
-    let mut model2 = UserModel::from_model(base2);
-
-    assert!(model2.apply_external_diffs(&bytes).is_ok());
-
-    // Verify the state matches
-    assert_eq!(model2.get_formatted_cell_value(0, 1, 1).unwrap(), "Test");
-}
-
-#[test]
-fn boundary_validation() {
-    let base = new_empty_model();
-    let mut model = UserModel::from_model(base);
-
-    // Test deleting rows beyond valid range
-    assert!(model.delete_rows(0, LAST_ROW, 2).is_err());
-    assert!(model.delete_rows(0, LAST_ROW + 1, 1).is_err());
-
-    // Test deleting columns beyond valid range
-    assert!(model.delete_columns(0, LAST_COLUMN, 2).is_err());
-    assert!(model.delete_columns(0, LAST_COLUMN + 1, 1).is_err());
-
-    // Test valid boundary deletions (should work with our empty row fix)
-    assert!(model.delete_rows(0, LAST_ROW, 1).is_ok());
-    assert!(model.delete_columns(0, LAST_COLUMN, 1).is_ok());
-}

base/src/test/user_model/test_border.rs

@@ -50,7 +50,10 @@ fn check_borders(model: &UserModel) {
                         assert_eq!(
                             Some(top_border),
                             top_cell_style.border.bottom,
-                            "(Top). Sheet: {sheet}, row: {row}, column: {column}"
+                            "(Top). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
                         );
                     }
                 }
@@ -62,7 +65,10 @@ fn check_borders(model: &UserModel) {
                         assert_eq!(
                             Some(right_border),
                             right_cell_style.border.left,
-                            "(Right). Sheet: {sheet}, row: {row}, column: {column}"
+                            "(Right). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
                         );
                     }
                 }
@@ -74,7 +80,10 @@ fn check_borders(model: &UserModel) {
                         assert_eq!(
                             Some(bottom_border),
                             bottom_cell_style.border.top,
-                            "(Bottom). Sheet: {sheet}, row: {row}, column: {column}"
+                            "(Bottom). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
                         );
                     }
                 }
@@ -85,7 +94,10 @@ fn check_borders(model: &UserModel) {
                         assert_eq!(
                             Some(left_border),
                             left_cell_style.border.right,
-                            "(Left). Sheet: {sheet}, row: {row}, column: {column}"
+                            "(Left). Sheet: {}, row: {}, column: {}",
+                            sheet,
+                            row,
+                            column
                         );
                     }
                 }

base/src/test/user_model/test_clear_cells.rs

@@ -89,67 +89,3 @@ fn clear_all_empty_cell() {
     model.undo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 1, 1), Ok("".to_string()));
 }
-
-#[test]
-fn issue_454() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model
-        .set_user_input(
-            0,
-            1,
-            1,
-            "Le presbytère n'a rien perdu de son charme, ni le jardin de son éclat.",
-        )
-        .unwrap();
-    model.set_user_input(0, 1, 2, "=ISTEXT(A1)").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("TRUE".to_string())
-    );
-    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, 2),
-        Ok("FALSE".to_string())
-    );
-    model.undo().unwrap();
-}
-
-#[test]
-fn issue_454b() {
-    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model
-        .set_user_input(
-            0,
-            1,
-            1,
-            "Le presbytère n'a rien perdu de son charme, ni le jardin de son éclat.",
-        )
-        .unwrap();
-    model.set_user_input(0, 1, 2, "=ISTEXT(A1)").unwrap();
-    assert_eq!(
-        model.get_formatted_cell_value(0, 1, 2),
-        Ok("TRUE".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, 2),
-        Ok("FALSE".to_string())
-    );
-    model.undo().unwrap();
-}

base/src/test/user_model/test_defined_names.rs

@@ -254,19 +254,19 @@ fn invalid_names() {
     // spaces
     assert_eq!(
         model.new_defined_name("A real", None, "Sheet1!$A$1"),
-        Err("Name: Invalid defined name".to_string())
+        Err("Invalid defined name".to_string())
     );
 
     // Starts with number
     assert_eq!(
         model.new_defined_name("2real", None, "Sheet1!$A$1"),
-        Err("Name: Invalid defined name".to_string())
+        Err("Invalid defined name".to_string())
     );
 
     // Updating also fails
     assert_eq!(
         model.update_defined_name("MyName", None, "My Name", None, "Sheet1!$A$1"),
-        Err("Name: Invalid defined name".to_string())
+        Err("Invalid defined name".to_string())
     );
 }
 
@@ -284,13 +284,13 @@ fn already_existing() {
     // Can't create a new name with the same name
     assert_eq!(
         model.new_defined_name("MyName", None, "Sheet1!$A$2"),
-        Err("Name: Defined name already exists".to_string())
+        Err("Defined name already exists".to_string())
     );
 
     // Can't update one into an existing
     assert_eq!(
         model.update_defined_name("Another", None, "MyName", None, "Sheet1!$A$1"),
-        Err("Name: Defined name already exists".to_string())
+        Err("Defined name already exists".to_string())
     );
 }
 
@@ -304,17 +304,17 @@ fn invalid_sheet() {
 
     assert_eq!(
         model.new_defined_name("Mything", Some(2), "Sheet1!$A$1"),
-        Err("Scope: Invalid sheet index".to_string())
+        Err("Invalid sheet index".to_string())
     );
 
     assert_eq!(
         model.update_defined_name("MyName", None, "MyName", Some(2), "Sheet1!$A$1"),
-        Err("Scope: Invalid sheet index".to_string())
+        Err("Invalid sheet index".to_string())
     );
 
     assert_eq!(
         model.update_defined_name("MyName", Some(9), "YourName", None, "Sheet1!$A$1"),
-        Err("General: Failed to get old name".to_string())
+        Err("Invalid sheet index".to_string())
     );
 }
 
@@ -322,7 +322,7 @@ fn invalid_sheet() {
 fn invalid_formula() {
     let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
     model.set_user_input(0, 1, 1, "Hello").unwrap();
-    assert!(model.new_defined_name("MyName", None, "A1").is_err());
+    model.new_defined_name("MyName", None, "A1").unwrap();
 
     model.set_user_input(0, 1, 2, "=MyName").unwrap();
 

base/src/test/user_model/test_diff_queue.rs

@@ -65,8 +65,8 @@ fn queue_undo_redo_multiple() {
         model1.set_user_input(0, row, 17, "=ROW()").unwrap();
     }
 
-    model1.insert_rows(0, 3, 1).unwrap();
+    model1.insert_row(0, 3).unwrap();
-    model1.insert_rows(0, 3, 1).unwrap();
+    model1.insert_row(0, 3).unwrap();
 
     // undo al of them
     while model1.can_undo() {

base/src/test/user_model/test_general.rs

@@ -26,7 +26,7 @@ fn set_user_input_errors() {
 #[test]
 fn user_model_debug_message() {
     let model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    let s = &format!("{model:?}");
+    let s = &format!("{:?}", model);
     assert_eq!(s, "UserModel");
 }
 
@@ -62,7 +62,7 @@ fn insert_remove_rows() {
     assert!(model.set_rows_height(0, 5, 5, 3.0 * height).is_ok());
 
     // remove the row
-    assert!(model.delete_rows(0, 5, 1).is_ok());
+    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
@@ -99,7 +99,7 @@ fn insert_remove_columns() {
     assert_eq!(model.get_column_width(0, 5).unwrap(), 3.0 * column_width);
 
     // remove the column
-    assert!(model.delete_columns(0, 5, 1).is_ok());
+    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

base/src/test/user_model/test_last_empty_cell.rs

@@ -1,55 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::constants::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 the first row, column 5
-    model.set_user_input(0, 3, 5, "todo").unwrap();
-
-    // Row 3 before column 5 should be empty
-    assert_eq!(
-        model
-            .get_last_non_empty_in_row_before_column(0, 3, 4)
-            .unwrap(),
-        None
-    );
-    // Row 3 before column 5 should be 5
-    assert_eq!(
-        model
-            .get_last_non_empty_in_row_before_column(0, 3, 7)
-            .unwrap(),
-        Some(5)
-    );
-}
-
-#[test]
-fn test_last_empty_cell() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    let column_g_range = Area {
-        sheet: 0,
-        row: 1,
-        column: 7,
-        width: 1,
-        height: LAST_ROW,
-    };
-
-    model
-        .update_range_style(&column_g_range, "fill.bg_color", "#333444")
-        .unwrap();
-
-    // Column 7 has a style but it is empty
-    assert_eq!(
-        model
-            .get_last_non_empty_in_row_before_column(0, 3, 14)
-            .unwrap(),
-        None
-    );
-}

base/src/test/user_model/test_multi_row_column.rs

@@ -1,173 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{
-    constants::{LAST_COLUMN, LAST_ROW},
-    test::util::new_empty_model,
-    UserModel,
-};
-
-#[test]
-fn insert_multiple_rows_shifts_cells() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    // Place a value below the insertion point.
-    model.set_user_input(0, 10, 1, "42").unwrap();
-
-    // Insert 3 rows starting at row 5.
-    assert!(model.insert_rows(0, 5, 3).is_ok());
-
-    // The original value should have moved down by 3 rows.
-    assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
-
-    // Undo / redo cycle should restore the same behaviour.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "42");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
-}
-
-#[test]
-fn insert_rows_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.insert_rows(0, 1, -2),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-    assert_eq!(
-        model.insert_rows(0, 1, 0),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-
-    // Inserting too many rows so that the sheet would overflow.
-    let too_many = LAST_ROW; // This guarantees max_row + too_many > LAST_ROW.
-    assert_eq!(
-        model.insert_rows(0, 1, too_many),
-        Err(
-            "Cannot shift cells because that would delete cells at the end of a column".to_string()
-        )
-    );
-}
-
-#[test]
-fn insert_multiple_columns_shifts_cells() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-    // Place a value to the right of the insertion point.
-    model.set_user_input(0, 1, 10, "99").unwrap();
-
-    // Insert 3 columns starting at column 5.
-    assert!(model.insert_columns(0, 5, 3).is_ok());
-
-    // The original value should have moved right by 3 columns.
-    assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
-
-    // Undo / redo cycle.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 10).unwrap(), "99");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
-}
-
-#[test]
-fn insert_columns_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.insert_columns(0, 1, -2),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-    assert_eq!(
-        model.insert_columns(0, 1, 0),
-        Err("Cannot add a negative number of cells :)".to_string())
-    );
-
-    // Overflow to the right.
-    let too_many = LAST_COLUMN; // Ensures max_column + too_many > LAST_COLUMN
-    assert_eq!(
-        model.insert_columns(0, 1, too_many),
-        Err("Cannot shift cells because that would delete cells at the end of a row".to_string())
-    );
-}
-
-#[test]
-fn delete_multiple_rows_shifts_cells_upwards() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Populate rows 10..14 (to be deleted) so that the diff builder does not fail.
-    for r in 10..15 {
-        model.set_user_input(0, r, 1, "del").unwrap();
-    }
-    // Place a value below the deletion range.
-    model.set_user_input(0, 20, 1, "keep").unwrap();
-
-    // Delete 5 rows starting at row 10.
-    assert!(model.delete_rows(0, 10, 5).is_ok());
-
-    // The value originally at row 20 should now be at row 15.
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
-
-    // Undo / redo cycle.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "keep");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
-}
-
-#[test]
-fn delete_rows_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.delete_rows(0, 1, -3),
-        Err("Please use insert rows instead".to_string())
-    );
-    assert_eq!(
-        model.delete_rows(0, 1, 0),
-        Err("Please use insert rows instead".to_string())
-    );
-}
-
-#[test]
-fn delete_multiple_columns_shifts_cells_left() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Place a value to the right of the deletion range.
-    model.set_user_input(0, 1, 15, "88").unwrap();
-
-    // Delete 4 columns starting at column 5.
-    assert!(model.delete_columns(0, 5, 4).is_ok());
-
-    // The value originally at column 15 should now be at column 11.
-    assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
-
-    // Undo / redo cycle.
-    model.undo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 15).unwrap(), "88");
-    model.redo().unwrap();
-    assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
-}
-
-#[test]
-fn delete_columns_errors() {
-    let model = new_empty_model();
-    let mut model = UserModel::from_model(model);
-
-    // Negative or zero counts are rejected.
-    assert_eq!(
-        model.delete_columns(0, 1, -4),
-        Err("Please use insert columns instead".to_string())
-    );
-    assert_eq!(
-        model.delete_columns(0, 1, 0),
-        Err("Please use insert columns instead".to_string())
-    );
-}

base/src/test/user_model/test_paste_csv.rs

@@ -24,7 +24,6 @@ fn csv_paste() {
         model.get_formatted_cell_value(0, 7, 7),
         Ok("21".to_string())
     );
-    assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
 }
 
 #[test]
@@ -46,7 +45,6 @@ fn csv_paste_formula() {
         model.get_formatted_cell_value(0, 1, 1),
         Ok("2022".to_string())
     );
-    assert_eq!([1, 1, 1, 1], model.get_selected_view().range);
 }
 
 #[test]
@@ -71,7 +69,6 @@ fn tsv_crlf_paste() {
         model.get_formatted_cell_value(0, 7, 7),
         Ok("21".to_string())
     );
-    assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
 }
 
 #[test]
@@ -167,7 +164,7 @@ fn copy_paste_internal() {
     let copy = model.copy_to_clipboard().unwrap();
     assert_eq!(
         copy.csv,
-        "42\t127\n\"A season of faith\t \"\"perfection\"\"\""
+        "42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
     );
     assert_eq!(copy.range, (1, 1, 2, 2));
 

base/src/test/user_model/test_row_column.rs

@@ -14,7 +14,7 @@ fn simple_insert_row() {
     for row in 1..5 {
         assert!(model.set_user_input(sheet, row, column, "123").is_ok());
     }
-    assert!(model.insert_rows(sheet, 3, 1).is_ok());
+    assert!(model.insert_row(sheet, 3).is_ok());
     assert_eq!(
         model.get_formatted_cell_value(sheet, 3, column).unwrap(),
         ""
@@ -40,7 +40,7 @@ fn simple_insert_column() {
     for column in 1..5 {
         assert!(model.set_user_input(sheet, row, column, "123").is_ok());
     }
-    assert!(model.insert_columns(sheet, 3, 1).is_ok());
+    assert!(model.insert_column(sheet, 3).is_ok());
     assert_eq!(model.get_formatted_cell_value(sheet, row, 3).unwrap(), "");
 
     assert!(model.undo().is_ok());
@@ -62,7 +62,7 @@ fn simple_delete_column() {
         .set_columns_width(0, 5, 5, DEFAULT_COLUMN_WIDTH * 3.0)
         .unwrap();
 
-    model.delete_columns(0, 5, 1).unwrap();
+    model.delete_column(0, 5).unwrap();
 
     assert_eq!(model.get_formatted_cell_value(0, 2, 5), Ok("".to_string()));
     assert_eq!(model.get_column_width(0, 5), Ok(DEFAULT_COLUMN_WIDTH));
@@ -92,20 +92,20 @@ fn delete_column_errors() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
     assert_eq!(
-        model.delete_columns(1, 1, 1),
+        model.delete_column(1, 1),
         Err("Invalid sheet index".to_string())
     );
 
     assert_eq!(
-        model.delete_columns(0, 0, 1),
+        model.delete_column(0, 0),
         Err("Column number '0' is not valid.".to_string())
     );
     assert_eq!(
-        model.delete_columns(0, LAST_COLUMN + 1, 1),
+        model.delete_column(0, LAST_COLUMN + 1),
-        Err(format!("Column number '{}' is not valid.", LAST_COLUMN + 1))
+        Err("Column number '16385' is not valid.".to_string())
     );
 
-    assert_eq!(model.delete_columns(0, LAST_COLUMN, 1), Ok(()));
+    assert_eq!(model.delete_column(0, LAST_COLUMN), Ok(()));
 }
 
 #[test]
@@ -119,7 +119,7 @@ fn simple_delete_row() {
         .set_rows_height(0, 15, 15, DEFAULT_ROW_HEIGHT * 3.0)
         .unwrap();
 
-    model.delete_rows(0, 15, 1).unwrap();
+    model.delete_row(0, 15).unwrap();
 
     assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
     assert_eq!(model.get_row_height(0, 15), Ok(DEFAULT_ROW_HEIGHT));
@@ -150,7 +150,7 @@ fn simple_delete_row_no_style() {
     let mut model = UserModel::from_model(model);
     model.set_user_input(0, 15, 4, "3").unwrap();
     model.set_user_input(0, 15, 6, "=D15*2").unwrap();
-    model.delete_rows(0, 15, 1).unwrap();
+    model.delete_row(0, 15).unwrap();
 
     assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
 }
@@ -180,14 +180,14 @@ fn insert_row_evaluates() {
     model.set_user_input(0, 1, 1, "42").unwrap();
     model.set_user_input(0, 1, 2, "=A1*2").unwrap();
 
-    assert!(model.insert_rows(0, 1, 1).is_ok());
+    assert!(model.insert_row(0, 1).is_ok());
     assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
     model.undo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
     model.redo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
 
-    model.delete_rows(0, 1, 1).unwrap();
+    model.delete_row(0, 1).unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
     assert_eq!(model.get_cell_content(0, 1, 2).unwrap(), "=A1*2");
 }
@@ -199,7 +199,7 @@ fn insert_column_evaluates() {
     model.set_user_input(0, 1, 1, "42").unwrap();
     model.set_user_input(0, 10, 1, "=A1*2").unwrap();
 
-    assert!(model.insert_columns(0, 1, 1).is_ok());
+    assert!(model.insert_column(0, 1).is_ok());
     assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
 
     model.undo().unwrap();
@@ -207,7 +207,7 @@ fn insert_column_evaluates() {
     model.redo().unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
 
-    model.delete_columns(0, 1, 1).unwrap();
+    model.delete_column(0, 1).unwrap();
     assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "84");
     assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1*2");
 }

base/src/test/user_model/test_view.rs

@@ -55,7 +55,7 @@ fn set_the_range_does_not_set_the_cell() {
     assert_eq!(
         model.set_selected_range(5, 4, 10, 6),
         Err(
-            "The selected cell is not in one of the corners. Row: '1' and row range '(5, 10)'"
+            "The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
                 .to_string()
         )
     );

base/src/test/user_model/util.rs

@@ -11,10 +11,11 @@ impl UserModel {
             r##"{{
                 "item": {{
                     "style": "thin",
-                    "color": "{color}"
+                    "color": "{}"
                 }},
                 "type": "All"
-            }}"##
+            }}"##,
+            color
         ))
         .unwrap();
         let range = &Area {
@@ -39,10 +40,11 @@ impl UserModel {
             r##"{{
                 "item": {{
                     "style": "thin",
-                    "color": "{color}"
+                    "color": "{}"
                 }},
-                "type": "{kind}"
+                "type": "{}"
-            }}"##
+            }}"##,
+            color, kind
         ))
         .unwrap();
         let range = &Area {