#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
#![allow(clippy::indexing_slicing)]
use sheet_core::refs::{cell_name, extract_refs, parse_cell_name, RANGE_CELL_CAP};
use sheet_core::{Cell, CellValue, DependencyGraph, ExcelError, GraphError, Sheet};
use std::vec::Vec;
#[test]
fn deep_chain_orders_without_recursion_limits() {
const N: u32 = 500;
let mut g = DependencyGraph::new();
for i in (0..N).rev() {
let formula = if i + 1 < N {
format!("={}", cell_name((i + 1, 0)))
} else {
String::from("=1")
};
g.add_formula((i, 0), &formula).unwrap();
}
let order = g.topological_order();
assert_eq!(order.len(), N as usize);
for (k, &cell) in order.iter().enumerate() {
assert_eq!(
cell,
(N - 1 - k as u32, 0),
"position {k} wrong in {order:?}"
);
}
assert!(g.has_circular().is_empty());
let dirty = g.dirty_subgraph(&[(N - 1, 0)]);
assert_eq!(dirty, g.topological_order());
}
#[test]
fn ring_reports_one_cycle_of_every_member() {
const N: u32 = 100;
let mut g = DependencyGraph::new();
for i in 0..N {
let next = (i + 1) % N;
g.add_formula((i, 0), &format!("={}", cell_name((next, 0))))
.unwrap();
}
let cycles = g.has_circular();
assert_eq!(cycles.len(), 1);
let cycle = &cycles[0];
assert_eq!(cycle.len(), N as usize);
assert_eq!(cycle[0], (0, 0));
assert_eq!(cycle[(N as usize) - 1], (N - 1, 0));
assert!(g.topological_order().is_empty());
}
#[test]
fn sheet_and_graph_work_together() {
let mut sheet = Sheet::new();
sheet.set(0, 0, Cell::number(41.0)); sheet.set(0, 1, Cell::number(1.0)); sheet.set(1, 0, Cell::formula("=A1+B1")); sheet.set(2, 0, Cell::formula("=A2*2")); sheet.set(3, 0, Cell::error(ExcelError::Ref));
assert_eq!(sheet.used_range(), Some(((0, 0), (3, 1))));
let mut g = DependencyGraph::new();
for (coord, cell) in sheet.iter() {
if let CellValue::Formula(text) = &cell.value {
g.add_formula(*coord, text).unwrap();
}
}
assert_eq!(g.formula_count(), 2);
assert_eq!(g.topological_order(), vec![(1, 0), (2, 0)]);
assert_eq!(g.dirty_subgraph(&[(0, 0)]), vec![(1, 0), (2, 0)]);
assert_eq!(g.dirty_subgraph(&[(0, 1)]), vec![(1, 0), (2, 0)]);
sheet.set(1, 0, Cell::number(0.0));
g.remove_formula((1, 0));
assert_eq!(g.dirty_subgraph(&[(0, 0)]), Vec::<(u32, u32)>::new());
assert_eq!(g.dirty_subgraph(&[(1, 0)]), vec![(2, 0)]);
}
#[test]
fn error_values_display_and_compare() {
let mut sheet = Sheet::new();
sheet.set(0, 0, Cell::new(CellValue::Error(ExcelError::Div0)));
assert_eq!(
sheet.get(0, 0).map(|c| match c.value {
CellValue::Error(e) => String::from(e.as_str()),
_ => String::from("wrong"),
}),
Some(String::from("#DIV/0!"))
);
assert_eq!(
CellValue::Error(ExcelError::Na),
CellValue::Error(ExcelError::Na)
);
}
#[test]
fn extraction_is_lenient_on_junk_but_strict_on_qualifiers() {
let refs = extract_refs("= 1A + Sheet2!B2").unwrap();
assert_eq!(refs, vec![(1, 1)]);
let err = extract_refs("=SUM(A1)+Sheet9!").unwrap_err();
assert!(
matches!(err, GraphError::InvalidReference { position: 15, .. }),
"{err:?}"
);
}
#[test]
fn cell_name_and_parse_are_inverse() {
for coord in [(0u32, 0u32), (12, 34), (1_048_575, 16_383), (7, 6)] {
let name = cell_name(coord);
assert_eq!(parse_cell_name(&name), Ok(coord), "{name} not inverse");
}
assert_eq!(parse_cell_name("$AB$12"), Ok((11, 27)));
}
#[test]
fn cap_boundary_is_exact() {
let refs = extract_refs("=A1:IV256").unwrap();
assert_eq!(refs.len() as u64, RANGE_CELL_CAP);
let err = extract_refs("=A1:IV257").unwrap_err();
assert!(
matches!(err, GraphError::RangeTooLarge { cells: 65_792, .. }),
"{err:?}"
);
}
#[test]
fn sheet_bounds_survive_pathological_removals() {
let mut sheet = Sheet::new();
for i in 0..10u32 {
sheet.set(i, i, Cell::number(f64::from(i)));
}
assert_eq!(sheet.used_range(), Some(((0, 0), (9, 9))));
for i in 0..5u32 {
sheet.remove(i, i);
}
assert_eq!(sheet.used_range(), Some(((5, 5), (9, 9))));
for i in 5..10u32 {
sheet.remove(i, i);
}
assert_eq!(sheet.used_range(), None);
assert_eq!(sheet.len(), 0);
sheet.set(2, 3, Cell::number(1.0));
assert_eq!(sheet.used_range(), Some(((2, 3), (2, 3))));
}