Skip to main content

sheetkit_core/
row.rs

1//! Row operations for worksheet manipulation.
2//!
3//! All functions operate directly on a [`WorksheetXml`] structure, keeping the
4//! business logic decoupled from the [`Workbook`](crate::workbook::Workbook)
5//! wrapper.
6
7use sheetkit_xml::worksheet::{CellTypeTag, Row, WorksheetXml};
8
9use crate::cell::CellValue;
10use crate::error::{Error, Result};
11use crate::raw_transfer::SharedFollowers;
12use crate::sst::SharedStringTable;
13use crate::traversal::{check_limit, TraversalLimits};
14use crate::utils::cell_ref::{cell_name_to_coordinates, compact_cell_ref};
15use crate::utils::constants::{MAX_COLUMNS, MAX_ROWS, MAX_ROW_HEIGHT};
16
17/// Get all rows with their data from a worksheet.
18///
19/// Returns a Vec of `(row_number, Vec<(column_number, CellValue)>)` tuples.
20/// Column numbers are 1-based (A=1, B=2, ...). Only rows that contain at
21/// least one cell are included (sparse).
22///
23/// `style_is_date` is a per-style-index flag (from
24/// [`crate::style::compute_style_is_date`]) that marks which styles carry
25/// a date number format. Pass an empty slice to skip date promotion, or
26/// the workbook's precomputed lookup to have `t="n"` cells with a date
27/// format returned as [`CellValue::Date`].
28#[allow(clippy::type_complexity)]
29pub fn get_rows(
30    ws: &WorksheetXml,
31    sst: &SharedStringTable,
32    style_is_date: &[bool],
33) -> Result<Vec<(u32, Vec<(u32, CellValue)>)>> {
34    get_rows_with_limits(ws, sst, style_is_date, TraversalLimits::default())
35}
36
37/// Gets sparse rows while bounding counts and retained cloned values.
38#[allow(clippy::type_complexity)]
39pub fn get_rows_with_limits(
40    ws: &WorksheetXml,
41    sst: &SharedStringTable,
42    style_is_date: &[bool],
43    limits: TraversalLimits,
44) -> Result<Vec<(u32, Vec<(u32, CellValue)>)>> {
45    let mut row_count = 0u64;
46    let mut column_count = 0u64;
47    let mut cell_count = 0u64;
48    let mut retained_bytes = 0u64;
49    let mut occupied_columns = [false; MAX_COLUMNS as usize];
50
51    for row in &ws.sheet_data.rows {
52        if row.cells.is_empty() {
53            continue;
54        }
55        row_count = row_count.saturating_add(1);
56        check_limit(
57            crate::resource::ResourceDimension::RowCount,
58            limits.max_rows(),
59            row_count,
60        )?;
61        retained_bytes = retained_bytes.saturating_add(
62            u64::try_from(std::mem::size_of::<(u32, Vec<(u32, CellValue)>)>()).unwrap_or(u64::MAX),
63        );
64
65        for cell in &row.cells {
66            let col_num = if cell.col > 0 {
67                cell.col
68            } else {
69                cell_name_to_coordinates(cell.r.as_str())?.0
70            };
71            if col_num == 0 || col_num > MAX_COLUMNS {
72                return Err(Error::InvalidColumnNumber(col_num));
73            }
74            let column_slot = usize::try_from(col_num - 1)
75                .map_err(|_| Error::Internal("column index is not addressable".to_string()))?;
76            if !occupied_columns[column_slot] {
77                occupied_columns[column_slot] = true;
78                column_count = column_count.saturating_add(1);
79                check_limit(
80                    crate::resource::ResourceDimension::ColumnCount,
81                    limits.max_columns(),
82                    column_count,
83                )?;
84            }
85            cell_count = cell_count.saturating_add(1);
86            check_limit(
87                crate::resource::ResourceDimension::CellCount,
88                limits.max_cells(),
89                cell_count,
90            )?;
91            retained_bytes = retained_bytes
92                .saturating_add(
93                    u64::try_from(std::mem::size_of::<(u32, CellValue)>()).unwrap_or(u64::MAX),
94                )
95                .saturating_add(cell_cloned_payload_bytes(cell, sst));
96            check_limit(
97                crate::resource::ResourceDimension::RetainedBytes,
98                limits.max_output_bytes(),
99                retained_bytes,
100            )?;
101        }
102    }
103
104    let mut result = Vec::new();
105    result
106        .try_reserve_exact(
107            usize::try_from(row_count)
108                .map_err(|_| Error::Internal("row result size is not addressable".to_string()))?,
109        )
110        .map_err(|_| Error::Internal("row result allocation failed".to_string()))?;
111
112    let mut followers = SharedFollowers::new(ws, limits, retained_bytes, None)?;
113    for row in &ws.sheet_data.rows {
114        if row.cells.is_empty() {
115            continue;
116        }
117
118        let mut cells = Vec::new();
119        cells
120            .try_reserve_exact(row.cells.len())
121            .map_err(|_| Error::Internal("cell result allocation failed".to_string()))?;
122        for cell in &row.cells {
123            let col_num = if cell.col > 0 {
124                cell.col
125            } else {
126                cell_name_to_coordinates(cell.r.as_str())?.0
127            };
128            let mut value = resolve_cell_value(cell, sst, style_is_date);
129            followers.resolve(&mut value, cell)?;
130            cells.push((col_num, value));
131        }
132
133        result.push((row.r, cells));
134    }
135
136    Ok(result)
137}
138
139pub(crate) fn cell_cloned_payload_bytes(
140    cell: &sheetkit_xml::worksheet::Cell,
141    sst: &SharedStringTable,
142) -> u64 {
143    let mut bytes = cell
144        .f
145        .as_ref()
146        .and_then(|formula| formula.value.as_ref())
147        .map_or(0u64, |value| u64::try_from(value.len()).unwrap_or(u64::MAX));
148    if cell.f.is_some() {
149        bytes = bytes
150            .saturating_add(u64::try_from(std::mem::size_of::<CellValue>()).unwrap_or(u64::MAX));
151    }
152    let value_bytes = match (cell.t, cell.v.as_deref()) {
153        (CellTypeTag::SharedString, Some(index)) => index
154            .parse::<usize>()
155            .ok()
156            .and_then(|index| sst.get(index))
157            .map_or(0u64, |value| u64::try_from(value.len()).unwrap_or(u64::MAX)),
158        (CellTypeTag::FormulaString | CellTypeTag::Error, Some(value)) => {
159            u64::try_from(value.len()).unwrap_or(u64::MAX)
160        }
161        (CellTypeTag::InlineString, _) => cell
162            .is
163            .as_ref()
164            .and_then(|value| value.t.as_ref())
165            .map_or(0u64, |value| u64::try_from(value.len()).unwrap_or(u64::MAX)),
166        _ => 0,
167    };
168    bytes.saturating_add(value_bytes)
169}
170
171/// Look up a shared string by index string. Returns `CellValue::Empty` if the
172/// index is not a valid integer or the SST does not contain the entry.
173pub fn resolve_sst_value(sst: &SharedStringTable, index: &str) -> CellValue {
174    let idx: usize = match index.parse() {
175        Ok(i) => i,
176        Err(_) => return CellValue::Empty,
177    };
178    let s = sst.get(idx).unwrap_or("").to_string();
179    CellValue::String(s)
180}
181
182/// Resolve a cell's typed value from its raw XML components.
183///
184/// Handles all cell type tags (shared string, boolean, error, inline string,
185/// formula string, number) and SST lookup. This is the core dispatch that both
186/// `resolve_cell_value` and future buffer-pack paths share.
187///
188/// When `promote_number_to_date` is `true`, non-formula numeric cells are
189/// returned as [`CellValue::Date`] rather than [`CellValue::Number`]. The
190/// caller decides whether promotion applies by consulting the cell's style
191/// index against its precomputed date-style lookup; this function stays
192/// style-agnostic.
193pub fn parse_cell_type_value(
194    cell_type: CellTypeTag,
195    value: Option<&str>,
196    formula: Option<&sheetkit_xml::worksheet::CellFormula>,
197    inline_str: Option<&sheetkit_xml::worksheet::InlineString>,
198    sst: &SharedStringTable,
199    promote_number_to_date: bool,
200) -> CellValue {
201    if let Some(f) = formula {
202        let expr = f.value.clone().unwrap_or_default();
203        let cached = match (cell_type, value) {
204            (CellTypeTag::Boolean, Some(v)) => Some(Box::new(CellValue::Bool(v == "1"))),
205            (CellTypeTag::Error, Some(v)) => Some(Box::new(classify_error_value(v))),
206            (CellTypeTag::FormulaString, Some(v)) => {
207                Some(Box::new(CellValue::String(v.to_string())))
208            }
209            (CellTypeTag::SharedString, Some(v)) => Some(Box::new(resolve_sst_value(sst, v))),
210            (CellTypeTag::InlineString, _) => Some(Box::new(CellValue::String(
211                inline_str
212                    .and_then(|value| value.t.clone())
213                    .unwrap_or_default(),
214            ))),
215            (CellTypeTag::None | CellTypeTag::Number, Some(v)) => {
216                v.parse::<f64>().ok().map(|number| {
217                    Box::new(if promote_number_to_date {
218                        CellValue::Date(number)
219                    } else {
220                        CellValue::Number(number)
221                    })
222                })
223            }
224            (_, Some(v)) => v
225                .parse::<f64>()
226                .ok()
227                .map(|number| Box::new(CellValue::Number(number))),
228            _ => None,
229        };
230        return CellValue::Formula {
231            expr,
232            result: cached,
233        };
234    }
235
236    match (cell_type, value) {
237        (CellTypeTag::SharedString, Some(v)) => resolve_sst_value(sst, v),
238        (CellTypeTag::Boolean, Some(v)) => CellValue::Bool(v == "1"),
239        (CellTypeTag::Error, Some(v)) => classify_error_value(v),
240        (CellTypeTag::InlineString, _) => {
241            let s = inline_str.and_then(|is| is.t.clone()).unwrap_or_default();
242            CellValue::String(s)
243        }
244        (CellTypeTag::FormulaString, Some(v)) => CellValue::String(v.to_string()),
245        (CellTypeTag::None | CellTypeTag::Number, Some(v)) => match v.parse::<f64>() {
246            Ok(n) => {
247                if promote_number_to_date {
248                    CellValue::Date(n)
249                } else {
250                    CellValue::Number(n)
251                }
252            }
253            Err(_) => CellValue::Empty,
254        },
255        _ => CellValue::Empty,
256    }
257}
258
259fn classify_error_value(value: &str) -> CellValue {
260    if crate::output::is_excel_error_token(value) {
261        CellValue::Error(value.to_string())
262    } else {
263        CellValue::String(value.to_string())
264    }
265}
266
267/// Resolve the value of an XML cell to a [`CellValue`], using the SST for
268/// shared string lookups. Thin wrapper over [`parse_cell_type_value`] that
269/// also consults `style_is_date` (indexed by `cell.s`) to decide whether a
270/// numeric cell should be surfaced as a date.
271///
272/// Pass an empty slice to disable date promotion; the returned values will
273/// then be spec-literal (`CellValue::Number` for `t="n"` cells regardless
274/// of number format).
275pub fn resolve_cell_value(
276    cell: &sheetkit_xml::worksheet::Cell,
277    sst: &SharedStringTable,
278    style_is_date: &[bool],
279) -> CellValue {
280    let promote_number_to_date = cell
281        .s
282        .and_then(|idx| style_is_date.get(idx as usize).copied())
283        .unwrap_or(false);
284    parse_cell_type_value(
285        cell.t,
286        cell.v.as_deref(),
287        cell.f.as_deref(),
288        cell.is.as_deref(),
289        sst,
290        promote_number_to_date,
291    )
292}
293
294/// Insert `count` empty rows starting at `start_row`, shifting existing rows
295/// at and below `start_row` downward.
296///
297/// Cell references inside shifted rows are updated so that e.g. "B5" becomes
298/// "B8" when 3 rows are inserted at row 5.
299pub fn insert_rows(ws: &mut WorksheetXml, start_row: u32, count: u32) -> Result<()> {
300    if start_row == 0 {
301        return Err(Error::InvalidRowNumber(0));
302    }
303    if count == 0 {
304        return Ok(());
305    }
306    // Validate that shifting won't exceed MAX_ROWS.
307    let max_existing = ws.sheet_data.rows.iter().map(|r| r.r).max().unwrap_or(0);
308    let furthest = max_existing.max(start_row);
309    if furthest.checked_add(count).is_none_or(|v| v > MAX_ROWS) {
310        return Err(Error::InvalidRowNumber(furthest.saturating_add(count)));
311    }
312
313    // Shift rows that are >= start_row downward by `count`.
314    // Iterate in reverse to avoid overwriting.
315    for row in ws.sheet_data.rows.iter_mut().rev() {
316        if row.r >= start_row {
317            let new_row_num = row.r + count;
318            shift_row_cells(row, new_row_num)?;
319            row.r = new_row_num;
320        }
321    }
322
323    Ok(())
324}
325
326/// Remove a single row, shifting rows below it upward by one.
327pub fn remove_row(ws: &mut WorksheetXml, row: u32) -> Result<()> {
328    if row == 0 {
329        return Err(Error::InvalidRowNumber(0));
330    }
331
332    // Remove the target row via binary search.
333    if let Ok(idx) = ws.sheet_data.rows.binary_search_by_key(&row, |r| r.r) {
334        ws.sheet_data.rows.remove(idx);
335    }
336
337    // Shift rows above `row` upward.
338    for r in ws.sheet_data.rows.iter_mut() {
339        if r.r > row {
340            let new_row_num = r.r - 1;
341            shift_row_cells(r, new_row_num)?;
342            r.r = new_row_num;
343        }
344    }
345
346    Ok(())
347}
348
349/// Duplicate a row, inserting the copy directly below the source row.
350pub fn duplicate_row(ws: &mut WorksheetXml, row: u32) -> Result<()> {
351    duplicate_row_to(ws, row, row + 1)
352}
353
354/// Duplicate a row to a specific target row number. Existing rows at and
355/// below `target` are shifted down to make room.
356pub fn duplicate_row_to(ws: &mut WorksheetXml, row: u32, target: u32) -> Result<()> {
357    if row == 0 {
358        return Err(Error::InvalidRowNumber(0));
359    }
360    if target == 0 {
361        return Err(Error::InvalidRowNumber(0));
362    }
363    if target > MAX_ROWS {
364        return Err(Error::InvalidRowNumber(target));
365    }
366
367    // Find and clone the source row via binary search.
368    let source = ws
369        .sheet_data
370        .rows
371        .binary_search_by_key(&row, |r| r.r)
372        .ok()
373        .map(|idx| ws.sheet_data.rows[idx].clone())
374        .ok_or(Error::InvalidRowNumber(row))?;
375
376    // Shift existing rows at target downward.
377    insert_rows(ws, target, 1)?;
378
379    // Build the duplicated row with updated cell references.
380    let mut new_row = source;
381    shift_row_cells(&mut new_row, target)?;
382    new_row.r = target;
383
384    // Insert the new row in sorted position via binary search.
385    match ws.sheet_data.rows.binary_search_by_key(&target, |r| r.r) {
386        Ok(idx) => ws.sheet_data.rows[idx] = new_row,
387        Err(pos) => ws.sheet_data.rows.insert(pos, new_row),
388    }
389
390    Ok(())
391}
392
393/// Set the height of a row in points. Creates the row if it does not exist.
394///
395/// Valid range: `0.0 ..= 409.0`.
396pub fn set_row_height(ws: &mut WorksheetXml, row: u32, height: f64) -> Result<()> {
397    if row == 0 || row > MAX_ROWS {
398        return Err(Error::InvalidRowNumber(row));
399    }
400    if !(0.0..=MAX_ROW_HEIGHT).contains(&height) {
401        return Err(Error::RowHeightExceeded {
402            height,
403            max: MAX_ROW_HEIGHT,
404        });
405    }
406
407    let r = find_or_create_row(ws, row);
408    r.ht = Some(height);
409    r.custom_height = Some(true);
410    Ok(())
411}
412
413/// Get the height of a row. Returns `None` if the row does not exist or has
414/// no explicit height set.
415pub fn get_row_height(ws: &WorksheetXml, row: u32) -> Option<f64> {
416    ws.sheet_data
417        .rows
418        .binary_search_by_key(&row, |r| r.r)
419        .ok()
420        .and_then(|idx| ws.sheet_data.rows[idx].ht)
421}
422
423/// Set the visibility of a row. Creates the row if it does not exist.
424pub fn set_row_visible(ws: &mut WorksheetXml, row: u32, visible: bool) -> Result<()> {
425    if row == 0 || row > MAX_ROWS {
426        return Err(Error::InvalidRowNumber(row));
427    }
428
429    let r = find_or_create_row(ws, row);
430    r.hidden = if visible { None } else { Some(true) };
431    Ok(())
432}
433
434/// Get the visibility of a row. Returns true if visible (not hidden).
435///
436/// Rows are visible by default, so this returns true if the row does not
437/// exist or has no explicit `hidden` attribute.
438pub fn get_row_visible(ws: &WorksheetXml, row: u32) -> bool {
439    ws.sheet_data
440        .rows
441        .binary_search_by_key(&row, |r| r.r)
442        .ok()
443        .and_then(|idx| ws.sheet_data.rows[idx].hidden)
444        .map(|h| !h)
445        .unwrap_or(true)
446}
447
448/// Get the outline (grouping) level of a row. Returns 0 if not set.
449pub fn get_row_outline_level(ws: &WorksheetXml, row: u32) -> u8 {
450    ws.sheet_data
451        .rows
452        .binary_search_by_key(&row, |r| r.r)
453        .ok()
454        .and_then(|idx| ws.sheet_data.rows[idx].outline_level)
455        .unwrap_or(0)
456}
457
458/// Set the outline (grouping) level of a row.
459///
460/// Valid range: `0..=7` (Excel supports up to 7 outline levels).
461pub fn set_row_outline_level(ws: &mut WorksheetXml, row: u32, level: u8) -> Result<()> {
462    if row == 0 || row > MAX_ROWS {
463        return Err(Error::InvalidRowNumber(row));
464    }
465    if level > 7 {
466        return Err(Error::OutlineLevelExceeded { level, max: 7 });
467    }
468
469    let r = find_or_create_row(ws, row);
470    r.outline_level = if level == 0 { None } else { Some(level) };
471    Ok(())
472}
473
474/// Set the style for an entire row. The `style_id` is the ID returned by
475/// `add_style()`. Setting a row style applies the `s` attribute on the row
476/// element and marks `customFormat` so Excel honours it.  Existing cells in
477/// the row also have their individual style updated.
478pub fn set_row_style(ws: &mut WorksheetXml, row: u32, style_id: u32) -> Result<()> {
479    if row == 0 || row > MAX_ROWS {
480        return Err(Error::InvalidRowNumber(row));
481    }
482
483    let r = find_or_create_row(ws, row);
484    r.s = Some(style_id);
485    r.custom_format = if style_id == 0 { None } else { Some(true) };
486
487    // Apply to all existing cells in the row.
488    for cell in r.cells.iter_mut() {
489        cell.s = Some(style_id);
490    }
491    Ok(())
492}
493
494/// Get the style ID for a row. Returns 0 (default) if the row does not
495/// exist or has no explicit style.
496pub fn get_row_style(ws: &WorksheetXml, row: u32) -> u32 {
497    ws.sheet_data
498        .rows
499        .binary_search_by_key(&row, |r| r.r)
500        .ok()
501        .and_then(|idx| ws.sheet_data.rows[idx].s)
502        .unwrap_or(0)
503}
504
505/// Update all cell references in a row to point to `new_row_num`.
506fn shift_row_cells(row: &mut Row, new_row_num: u32) -> Result<()> {
507    for cell in row.cells.iter_mut() {
508        let (col, _) = cell_name_to_coordinates(cell.r.as_str())?;
509        cell.r = compact_cell_ref(col, new_row_num)?;
510        cell.col = col;
511    }
512    Ok(())
513}
514
515/// Find an existing row or create a new empty one, keeping rows sorted.
516/// Uses binary search for O(log n) lookup instead of linear scan.
517fn find_or_create_row(ws: &mut WorksheetXml, row: u32) -> &mut Row {
518    match ws.sheet_data.rows.binary_search_by_key(&row, |r| r.r) {
519        Ok(idx) => &mut ws.sheet_data.rows[idx],
520        Err(pos) => {
521            ws.sheet_data.rows.insert(
522                pos,
523                Row {
524                    r: row,
525                    spans: None,
526                    s: None,
527                    custom_format: None,
528                    ht: None,
529                    hidden: None,
530                    custom_height: None,
531                    outline_level: None,
532                    cells: vec![],
533                },
534            );
535            &mut ws.sheet_data.rows[pos]
536        }
537    }
538}
539
540#[cfg(test)]
541#[allow(clippy::field_reassign_with_default)]
542mod tests {
543    use super::*;
544    use sheetkit_xml::worksheet::{Cell, CellTypeTag, SheetData};
545
546    /// Helper: build a minimal worksheet with some pre-populated rows.
547    fn sample_ws() -> WorksheetXml {
548        let mut ws = WorksheetXml::default();
549        ws.sheet_data = SheetData {
550            rows: vec![
551                Row {
552                    r: 1,
553                    spans: None,
554                    s: None,
555                    custom_format: None,
556                    ht: None,
557                    hidden: None,
558                    custom_height: None,
559                    outline_level: None,
560                    cells: vec![
561                        Cell {
562                            r: "A1".try_into().unwrap(),
563                            col: 1,
564                            s: None,
565                            t: CellTypeTag::None,
566                            v: Some("10".to_string()),
567                            f: None,
568                            is: None,
569                        },
570                        Cell {
571                            r: "B1".try_into().unwrap(),
572                            col: 2,
573                            s: None,
574                            t: CellTypeTag::None,
575                            v: Some("20".to_string()),
576                            f: None,
577                            is: None,
578                        },
579                    ],
580                },
581                Row {
582                    r: 2,
583                    spans: None,
584                    s: None,
585                    custom_format: None,
586                    ht: None,
587                    hidden: None,
588                    custom_height: None,
589                    outline_level: None,
590                    cells: vec![Cell {
591                        r: "A2".try_into().unwrap(),
592                        col: 1,
593                        s: None,
594                        t: CellTypeTag::None,
595                        v: Some("30".to_string()),
596                        f: None,
597                        is: None,
598                    }],
599                },
600                Row {
601                    r: 5,
602                    spans: None,
603                    s: None,
604                    custom_format: None,
605                    ht: None,
606                    hidden: None,
607                    custom_height: None,
608                    outline_level: None,
609                    cells: vec![Cell {
610                        r: "C5".try_into().unwrap(),
611                        col: 3,
612                        s: None,
613                        t: CellTypeTag::None,
614                        v: Some("50".to_string()),
615                        f: None,
616                        is: None,
617                    }],
618                },
619            ],
620        };
621        ws
622    }
623
624    #[test]
625    fn bounded_rows_charge_repeated_shared_strings_before_cloning() {
626        let mut sst = SharedStringTable::new();
627        sst.add(&"x".repeat(1_024));
628        let mut ws = WorksheetXml::default();
629        ws.sheet_data.rows.push(Row {
630            r: 1,
631            spans: None,
632            s: None,
633            custom_format: None,
634            ht: None,
635            hidden: None,
636            custom_height: None,
637            outline_level: None,
638            cells: vec![
639                Cell {
640                    r: "A1".try_into().unwrap(),
641                    col: 1,
642                    s: None,
643                    t: CellTypeTag::SharedString,
644                    v: Some("0".to_string()),
645                    f: None,
646                    is: None,
647                },
648                Cell {
649                    r: "B1".try_into().unwrap(),
650                    col: 2,
651                    s: None,
652                    t: CellTypeTag::SharedString,
653                    v: Some("0".to_string()),
654                    f: None,
655                    is: None,
656                },
657            ],
658        });
659        let exact = u64::try_from(std::mem::size_of::<(u32, Vec<(u32, CellValue)>)>()).unwrap()
660            + 2 * (u64::try_from(std::mem::size_of::<(u32, CellValue)>()).unwrap() + 1_024);
661        let exact_limits = TraversalLimits::new(1, 2, 2, exact).unwrap();
662
663        let bounded = get_rows_with_limits(&ws, &sst, &[], exact_limits).unwrap();
664        assert_eq!(bounded, get_rows(&ws, &sst, &[]).unwrap());
665
666        let error = get_rows_with_limits(
667            &ws,
668            &sst,
669            &[],
670            TraversalLimits::new(1, 2, 2, exact - 1).unwrap(),
671        )
672        .unwrap_err();
673        let Error::ResourceLimitExceeded(metadata) = error else {
674            panic!("expected resource limit error");
675        };
676        assert_eq!(
677            metadata.dimension(),
678            crate::ResourceDimension::RetainedBytes
679        );
680        assert_eq!(metadata.limit(), exact - 1);
681        assert_eq!(metadata.observed(), exact);
682
683        let error = get_rows_with_limits(
684            &ws,
685            &sst,
686            &[],
687            TraversalLimits::new(1, 1, 2, exact).unwrap(),
688        )
689        .unwrap_err();
690        let Error::ResourceLimitExceeded(metadata) = error else {
691            panic!("expected resource limit error");
692        };
693        assert_eq!(metadata.dimension(), crate::ResourceDimension::ColumnCount);
694        assert_eq!(metadata.limit(), 1);
695        assert_eq!(metadata.observed(), 2);
696    }
697
698    #[test]
699    fn test_insert_rows_shifts_cells_down() {
700        let mut ws = sample_ws();
701        insert_rows(&mut ws, 2, 3).unwrap();
702
703        // Row 1 should be untouched.
704        assert_eq!(ws.sheet_data.rows[0].r, 1);
705        assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
706
707        // Row 2 -> 5 (shifted by 3).
708        assert_eq!(ws.sheet_data.rows[1].r, 5);
709        assert_eq!(ws.sheet_data.rows[1].cells[0].r, "A5");
710
711        // Row 5 -> 8 (shifted by 3).
712        assert_eq!(ws.sheet_data.rows[2].r, 8);
713        assert_eq!(ws.sheet_data.rows[2].cells[0].r, "C8");
714    }
715
716    #[test]
717    fn test_insert_rows_at_row_1() {
718        let mut ws = sample_ws();
719        insert_rows(&mut ws, 1, 2).unwrap();
720
721        // All rows shift by 2.
722        assert_eq!(ws.sheet_data.rows[0].r, 3);
723        assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A3");
724        assert_eq!(ws.sheet_data.rows[1].r, 4);
725        assert_eq!(ws.sheet_data.rows[2].r, 7);
726    }
727
728    #[test]
729    fn test_insert_rows_count_zero_is_noop() {
730        let mut ws = sample_ws();
731        insert_rows(&mut ws, 1, 0).unwrap();
732        assert_eq!(ws.sheet_data.rows[0].r, 1);
733        assert_eq!(ws.sheet_data.rows[1].r, 2);
734        assert_eq!(ws.sheet_data.rows[2].r, 5);
735    }
736
737    #[test]
738    fn test_insert_rows_row_zero_returns_error() {
739        let mut ws = sample_ws();
740        let result = insert_rows(&mut ws, 0, 1);
741        assert!(result.is_err());
742    }
743
744    #[test]
745    fn test_insert_rows_beyond_max_returns_error() {
746        let mut ws = WorksheetXml::default();
747        ws.sheet_data.rows.push(Row {
748            r: MAX_ROWS,
749            spans: None,
750            s: None,
751            custom_format: None,
752            ht: None,
753            hidden: None,
754            custom_height: None,
755            outline_level: None,
756            cells: vec![],
757        });
758        let result = insert_rows(&mut ws, 1, 1);
759        assert!(result.is_err());
760    }
761
762    #[test]
763    fn test_insert_rows_u32_overflow_returns_error_without_mutation() {
764        let mut ws = sample_ws();
765        let before = ws.clone();
766
767        let result = insert_rows(&mut ws, 1, u32::MAX);
768
769        assert!(matches!(result, Err(Error::InvalidRowNumber(u32::MAX))));
770        assert_eq!(ws, before);
771    }
772
773    #[test]
774    fn test_insert_rows_on_empty_sheet() {
775        let mut ws = WorksheetXml::default();
776        insert_rows(&mut ws, 1, 5).unwrap();
777        assert!(ws.sheet_data.rows.is_empty());
778    }
779
780    #[test]
781    fn test_remove_row_shifts_up() {
782        let mut ws = sample_ws();
783        remove_row(&mut ws, 2).unwrap();
784
785        // Row 1 untouched.
786        assert_eq!(ws.sheet_data.rows[0].r, 1);
787        assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
788
789        // Original row 2 is gone; row 5 shifted to 4.
790        assert_eq!(ws.sheet_data.rows.len(), 2);
791        assert_eq!(ws.sheet_data.rows[1].r, 4);
792        assert_eq!(ws.sheet_data.rows[1].cells[0].r, "C4");
793    }
794
795    #[test]
796    fn test_remove_first_row() {
797        let mut ws = sample_ws();
798        remove_row(&mut ws, 1).unwrap();
799
800        // Remaining rows shift up.
801        assert_eq!(ws.sheet_data.rows[0].r, 1);
802        assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
803        assert_eq!(ws.sheet_data.rows[1].r, 4);
804    }
805
806    #[test]
807    fn test_remove_nonexistent_row_still_shifts() {
808        let mut ws = sample_ws();
809        // Row 3 doesn't exist, but rows below should shift.
810        remove_row(&mut ws, 3).unwrap();
811        assert_eq!(ws.sheet_data.rows.len(), 3); // no row removed
812        assert_eq!(ws.sheet_data.rows[2].r, 4); // row 5 -> 4
813    }
814
815    #[test]
816    fn test_remove_row_zero_returns_error() {
817        let mut ws = sample_ws();
818        let result = remove_row(&mut ws, 0);
819        assert!(result.is_err());
820    }
821
822    #[test]
823    fn test_duplicate_row_inserts_copy_below() {
824        let mut ws = sample_ws();
825        duplicate_row(&mut ws, 1).unwrap();
826
827        // Row 1 stays.
828        assert_eq!(ws.sheet_data.rows[0].r, 1);
829        assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
830        assert_eq!(ws.sheet_data.rows[0].cells[0].v, Some("10".to_string()));
831
832        // Row 2 is the duplicate with updated refs.
833        assert_eq!(ws.sheet_data.rows[1].r, 2);
834        assert_eq!(ws.sheet_data.rows[1].cells[0].r, "A2");
835        assert_eq!(ws.sheet_data.rows[1].cells[0].v, Some("10".to_string()));
836        assert_eq!(ws.sheet_data.rows[1].cells.len(), 2);
837
838        // Original row 2 shifted to 3.
839        assert_eq!(ws.sheet_data.rows[2].r, 3);
840        assert_eq!(ws.sheet_data.rows[2].cells[0].r, "A3");
841    }
842
843    #[test]
844    fn test_duplicate_row_to_specific_target() {
845        let mut ws = sample_ws();
846        duplicate_row_to(&mut ws, 1, 5).unwrap();
847
848        // Row 1 unchanged.
849        assert_eq!(ws.sheet_data.rows[0].r, 1);
850
851        // Target row 5 is the copy.
852        let row5 = ws.sheet_data.rows.iter().find(|r| r.r == 5).unwrap();
853        assert_eq!(row5.cells[0].r, "A5");
854        assert_eq!(row5.cells[0].v, Some("10".to_string()));
855
856        // Original row 5 shifted to 6.
857        let row6 = ws.sheet_data.rows.iter().find(|r| r.r == 6).unwrap();
858        assert_eq!(row6.cells[0].r, "C6");
859    }
860
861    #[test]
862    fn test_duplicate_nonexistent_row_returns_error() {
863        let mut ws = sample_ws();
864        let result = duplicate_row(&mut ws, 99);
865        assert!(result.is_err());
866    }
867
868    #[test]
869    fn test_set_and_get_row_height() {
870        let mut ws = sample_ws();
871        set_row_height(&mut ws, 1, 25.5).unwrap();
872
873        assert_eq!(get_row_height(&ws, 1), Some(25.5));
874        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
875        assert_eq!(row.custom_height, Some(true));
876    }
877
878    #[test]
879    fn test_set_row_height_creates_row_if_missing() {
880        let mut ws = WorksheetXml::default();
881        set_row_height(&mut ws, 10, 30.0).unwrap();
882
883        assert_eq!(get_row_height(&ws, 10), Some(30.0));
884        assert_eq!(ws.sheet_data.rows.len(), 1);
885        assert_eq!(ws.sheet_data.rows[0].r, 10);
886    }
887
888    #[test]
889    fn test_set_row_height_zero_is_valid() {
890        let mut ws = WorksheetXml::default();
891        set_row_height(&mut ws, 1, 0.0).unwrap();
892        assert_eq!(get_row_height(&ws, 1), Some(0.0));
893    }
894
895    #[test]
896    fn test_set_row_height_max_is_valid() {
897        let mut ws = WorksheetXml::default();
898        set_row_height(&mut ws, 1, 409.0).unwrap();
899        assert_eq!(get_row_height(&ws, 1), Some(409.0));
900    }
901
902    #[test]
903    fn test_set_row_height_exceeds_max_returns_error() {
904        let mut ws = WorksheetXml::default();
905        let result = set_row_height(&mut ws, 1, 410.0);
906        assert!(result.is_err());
907        assert!(matches!(
908            result.unwrap_err(),
909            Error::RowHeightExceeded { .. }
910        ));
911    }
912
913    #[test]
914    fn test_set_row_height_negative_returns_error() {
915        let mut ws = WorksheetXml::default();
916        let result = set_row_height(&mut ws, 1, -1.0);
917        assert!(result.is_err());
918    }
919
920    #[test]
921    fn test_set_row_height_row_zero_returns_error() {
922        let mut ws = WorksheetXml::default();
923        let result = set_row_height(&mut ws, 0, 15.0);
924        assert!(result.is_err());
925    }
926
927    #[test]
928    fn test_get_row_height_nonexistent_returns_none() {
929        let ws = WorksheetXml::default();
930        assert_eq!(get_row_height(&ws, 99), None);
931    }
932
933    #[test]
934    fn test_set_row_hidden() {
935        let mut ws = sample_ws();
936        set_row_visible(&mut ws, 1, false).unwrap();
937
938        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
939        assert_eq!(row.hidden, Some(true));
940    }
941
942    #[test]
943    fn test_set_row_visible_clears_hidden() {
944        let mut ws = sample_ws();
945        set_row_visible(&mut ws, 1, false).unwrap();
946        set_row_visible(&mut ws, 1, true).unwrap();
947
948        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
949        assert_eq!(row.hidden, None);
950    }
951
952    #[test]
953    fn test_set_row_visible_creates_row_if_missing() {
954        let mut ws = WorksheetXml::default();
955        set_row_visible(&mut ws, 3, false).unwrap();
956        assert_eq!(ws.sheet_data.rows.len(), 1);
957        assert_eq!(ws.sheet_data.rows[0].r, 3);
958        assert_eq!(ws.sheet_data.rows[0].hidden, Some(true));
959    }
960
961    #[test]
962    fn test_set_row_visible_row_zero_returns_error() {
963        let mut ws = WorksheetXml::default();
964        let result = set_row_visible(&mut ws, 0, true);
965        assert!(result.is_err());
966    }
967
968    #[test]
969    fn test_set_row_outline_level() {
970        let mut ws = sample_ws();
971        set_row_outline_level(&mut ws, 1, 3).unwrap();
972
973        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
974        assert_eq!(row.outline_level, Some(3));
975    }
976
977    #[test]
978    fn test_set_row_outline_level_zero_clears() {
979        let mut ws = sample_ws();
980        set_row_outline_level(&mut ws, 1, 3).unwrap();
981        set_row_outline_level(&mut ws, 1, 0).unwrap();
982
983        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
984        assert_eq!(row.outline_level, None);
985    }
986
987    #[test]
988    fn test_set_row_outline_level_exceeds_max_returns_error() {
989        let mut ws = sample_ws();
990        let result = set_row_outline_level(&mut ws, 1, 8);
991        assert!(result.is_err());
992    }
993
994    #[test]
995    fn test_set_row_outline_level_row_zero_returns_error() {
996        let mut ws = WorksheetXml::default();
997        let result = set_row_outline_level(&mut ws, 0, 1);
998        assert!(result.is_err());
999    }
1000
1001    #[test]
1002    fn test_get_row_visible_default_is_true() {
1003        let ws = sample_ws();
1004        assert!(get_row_visible(&ws, 1));
1005    }
1006
1007    #[test]
1008    fn test_get_row_visible_nonexistent_row_is_true() {
1009        let ws = WorksheetXml::default();
1010        assert!(get_row_visible(&ws, 99));
1011    }
1012
1013    #[test]
1014    fn test_get_row_visible_after_hide() {
1015        let mut ws = sample_ws();
1016        set_row_visible(&mut ws, 1, false).unwrap();
1017        assert!(!get_row_visible(&ws, 1));
1018    }
1019
1020    #[test]
1021    fn test_get_row_visible_after_hide_then_show() {
1022        let mut ws = sample_ws();
1023        set_row_visible(&mut ws, 1, false).unwrap();
1024        set_row_visible(&mut ws, 1, true).unwrap();
1025        assert!(get_row_visible(&ws, 1));
1026    }
1027
1028    #[test]
1029    fn test_get_row_outline_level_default_is_zero() {
1030        let ws = sample_ws();
1031        assert_eq!(get_row_outline_level(&ws, 1), 0);
1032    }
1033
1034    #[test]
1035    fn test_get_row_outline_level_nonexistent_row() {
1036        let ws = WorksheetXml::default();
1037        assert_eq!(get_row_outline_level(&ws, 99), 0);
1038    }
1039
1040    #[test]
1041    fn test_get_row_outline_level_after_set() {
1042        let mut ws = sample_ws();
1043        set_row_outline_level(&mut ws, 1, 5).unwrap();
1044        assert_eq!(get_row_outline_level(&ws, 1), 5);
1045    }
1046
1047    #[test]
1048    fn test_get_row_outline_level_after_clear() {
1049        let mut ws = sample_ws();
1050        set_row_outline_level(&mut ws, 1, 3).unwrap();
1051        set_row_outline_level(&mut ws, 1, 0).unwrap();
1052        assert_eq!(get_row_outline_level(&ws, 1), 0);
1053    }
1054
1055    // -- get_rows tests --
1056
1057    #[test]
1058    fn test_get_rows_empty_sheet() {
1059        let ws = WorksheetXml::default();
1060        let sst = SharedStringTable::new();
1061        let rows = get_rows(&ws, &sst, &[]).unwrap();
1062        assert!(rows.is_empty());
1063    }
1064
1065    #[test]
1066    fn test_get_rows_returns_numeric_values() {
1067        let ws = sample_ws();
1068        let sst = SharedStringTable::new();
1069        let rows = get_rows(&ws, &sst, &[]).unwrap();
1070
1071        assert_eq!(rows.len(), 3);
1072
1073        // Row 1: A1=10, B1=20
1074        assert_eq!(rows[0].0, 1);
1075        assert_eq!(rows[0].1.len(), 2);
1076        assert_eq!(rows[0].1[0].0, 1);
1077        assert_eq!(rows[0].1[0].1, CellValue::Number(10.0));
1078        assert_eq!(rows[0].1[1].0, 2);
1079        assert_eq!(rows[0].1[1].1, CellValue::Number(20.0));
1080
1081        // Row 2: A2=30
1082        assert_eq!(rows[1].0, 2);
1083        assert_eq!(rows[1].1.len(), 1);
1084        assert_eq!(rows[1].1[0].0, 1);
1085        assert_eq!(rows[1].1[0].1, CellValue::Number(30.0));
1086
1087        // Row 5: C5=50 (sparse -- rows 3 and 4 skipped)
1088        assert_eq!(rows[2].0, 5);
1089        assert_eq!(rows[2].1.len(), 1);
1090        assert_eq!(rows[2].1[0].0, 3);
1091        assert_eq!(rows[2].1[0].1, CellValue::Number(50.0));
1092    }
1093
1094    #[test]
1095    fn test_get_rows_shared_strings() {
1096        let mut sst = SharedStringTable::new();
1097        sst.add("hello");
1098        sst.add("world");
1099
1100        let mut ws = WorksheetXml::default();
1101        ws.sheet_data = SheetData {
1102            rows: vec![Row {
1103                r: 1,
1104                spans: None,
1105                s: None,
1106                custom_format: None,
1107                ht: None,
1108                hidden: None,
1109                custom_height: None,
1110                outline_level: None,
1111                cells: vec![
1112                    Cell {
1113                        r: "A1".try_into().unwrap(),
1114                        col: 1,
1115                        s: None,
1116                        t: CellTypeTag::SharedString,
1117                        v: Some("0".to_string()),
1118                        f: None,
1119                        is: None,
1120                    },
1121                    Cell {
1122                        r: "B1".try_into().unwrap(),
1123                        col: 2,
1124                        s: None,
1125                        t: CellTypeTag::SharedString,
1126                        v: Some("1".to_string()),
1127                        f: None,
1128                        is: None,
1129                    },
1130                ],
1131            }],
1132        };
1133
1134        let rows = get_rows(&ws, &sst, &[]).unwrap();
1135        assert_eq!(rows.len(), 1);
1136        assert_eq!(rows[0].1[0].1, CellValue::String("hello".to_string()));
1137        assert_eq!(rows[0].1[1].1, CellValue::String("world".to_string()));
1138    }
1139
1140    #[test]
1141    fn test_get_rows_mixed_types() {
1142        let mut sst = SharedStringTable::new();
1143        sst.add("text");
1144
1145        let mut ws = WorksheetXml::default();
1146        ws.sheet_data = SheetData {
1147            rows: vec![Row {
1148                r: 1,
1149                spans: None,
1150                s: None,
1151                custom_format: None,
1152                ht: None,
1153                hidden: None,
1154                custom_height: None,
1155                outline_level: None,
1156                cells: vec![
1157                    Cell {
1158                        r: "A1".try_into().unwrap(),
1159                        col: 1,
1160                        s: None,
1161                        t: CellTypeTag::SharedString,
1162                        v: Some("0".to_string()),
1163                        f: None,
1164                        is: None,
1165                    },
1166                    Cell {
1167                        r: "B1".try_into().unwrap(),
1168                        col: 2,
1169                        s: None,
1170                        t: CellTypeTag::None,
1171                        v: Some("42.5".to_string()),
1172                        f: None,
1173                        is: None,
1174                    },
1175                    Cell {
1176                        r: "C1".try_into().unwrap(),
1177                        col: 3,
1178                        s: None,
1179                        t: CellTypeTag::Boolean,
1180                        v: Some("1".to_string()),
1181                        f: None,
1182                        is: None,
1183                    },
1184                    Cell {
1185                        r: "D1".try_into().unwrap(),
1186                        col: 4,
1187                        s: None,
1188                        t: CellTypeTag::Error,
1189                        v: Some("#DIV/0!".to_string()),
1190                        f: None,
1191                        is: None,
1192                    },
1193                ],
1194            }],
1195        };
1196
1197        let rows = get_rows(&ws, &sst, &[]).unwrap();
1198        assert_eq!(rows.len(), 1);
1199        assert_eq!(rows[0].1[0].1, CellValue::String("text".to_string()));
1200        assert_eq!(rows[0].1[1].1, CellValue::Number(42.5));
1201        assert_eq!(rows[0].1[2].1, CellValue::Bool(true));
1202        assert_eq!(rows[0].1[3].1, CellValue::Error("#DIV/0!".to_string()));
1203    }
1204
1205    #[test]
1206    fn test_get_rows_skips_rows_with_no_cells() {
1207        let mut ws = WorksheetXml::default();
1208        ws.sheet_data = SheetData {
1209            rows: vec![
1210                Row {
1211                    r: 1,
1212                    spans: None,
1213                    s: None,
1214                    custom_format: None,
1215                    ht: None,
1216                    hidden: None,
1217                    custom_height: None,
1218                    outline_level: None,
1219                    cells: vec![Cell {
1220                        r: "A1".try_into().unwrap(),
1221                        col: 1,
1222                        s: None,
1223                        t: CellTypeTag::None,
1224                        v: Some("1".to_string()),
1225                        f: None,
1226                        is: None,
1227                    }],
1228                },
1229                // Row 2 exists but has no cells (e.g., only has row height set).
1230                Row {
1231                    r: 2,
1232                    spans: None,
1233                    s: None,
1234                    custom_format: None,
1235                    ht: Some(30.0),
1236                    hidden: None,
1237                    custom_height: Some(true),
1238                    outline_level: None,
1239                    cells: vec![],
1240                },
1241                Row {
1242                    r: 3,
1243                    spans: None,
1244                    s: None,
1245                    custom_format: None,
1246                    ht: None,
1247                    hidden: None,
1248                    custom_height: None,
1249                    outline_level: None,
1250                    cells: vec![Cell {
1251                        r: "A3".try_into().unwrap(),
1252                        col: 1,
1253                        s: None,
1254                        t: CellTypeTag::None,
1255                        v: Some("3".to_string()),
1256                        f: None,
1257                        is: None,
1258                    }],
1259                },
1260            ],
1261        };
1262
1263        let sst = SharedStringTable::new();
1264        let rows = get_rows(&ws, &sst, &[]).unwrap();
1265        // Only rows 1 and 3 should be returned (row 2 has no cells).
1266        assert_eq!(rows.len(), 2);
1267        assert_eq!(rows[0].0, 1);
1268        assert_eq!(rows[1].0, 3);
1269    }
1270
1271    #[test]
1272    fn test_get_rows_with_formula() {
1273        let mut ws = WorksheetXml::default();
1274        ws.sheet_data = SheetData {
1275            rows: vec![Row {
1276                r: 1,
1277                spans: None,
1278                s: None,
1279                custom_format: None,
1280                ht: None,
1281                hidden: None,
1282                custom_height: None,
1283                outline_level: None,
1284                cells: vec![Cell {
1285                    r: "A1".try_into().unwrap(),
1286                    col: 1,
1287                    s: None,
1288                    t: CellTypeTag::None,
1289                    v: Some("42".to_string()),
1290                    f: Some(Box::new(sheetkit_xml::worksheet::CellFormula {
1291                        t: None,
1292                        reference: None,
1293                        si: None,
1294                        value: Some("B1+C1".to_string()),
1295                    })),
1296                    is: None,
1297                }],
1298            }],
1299        };
1300
1301        let sst = SharedStringTable::new();
1302        let rows = get_rows(&ws, &sst, &[]).unwrap();
1303        assert_eq!(rows.len(), 1);
1304        match &rows[0].1[0].1 {
1305            CellValue::Formula { expr, result } => {
1306                assert_eq!(expr, "B1+C1");
1307                assert_eq!(*result, Some(Box::new(CellValue::Number(42.0))));
1308            }
1309            _ => panic!("expected Formula"),
1310        }
1311    }
1312
1313    #[test]
1314    fn test_formula_cached_results_preserve_cell_types() {
1315        let formula = sheetkit_xml::worksheet::CellFormula {
1316            t: None,
1317            reference: None,
1318            si: None,
1319            value: Some("A1".to_string()),
1320        };
1321        let sst = SharedStringTable::new();
1322
1323        let cases = [
1324            (CellTypeTag::Boolean, "1", false, CellValue::Bool(true)),
1325            (
1326                CellTypeTag::Error,
1327                "#N/A",
1328                false,
1329                CellValue::Error("#N/A".to_string()),
1330            ),
1331            (
1332                CellTypeTag::FormulaString,
1333                "=dangerous text",
1334                false,
1335                CellValue::String("=dangerous text".to_string()),
1336            ),
1337            (
1338                CellTypeTag::Number,
1339                "45292",
1340                true,
1341                CellValue::Date(45_292.0),
1342            ),
1343        ];
1344
1345        for (cell_type, value, promote_number_to_date, expected) in cases {
1346            let resolved = parse_cell_type_value(
1347                cell_type,
1348                Some(value),
1349                Some(&formula),
1350                None,
1351                &sst,
1352                promote_number_to_date,
1353            );
1354            assert_eq!(
1355                resolved,
1356                CellValue::Formula {
1357                    expr: "A1".to_string(),
1358                    result: Some(Box::new(expected)),
1359                }
1360            );
1361        }
1362    }
1363
1364    #[test]
1365    fn test_invalid_error_payloads_are_classified_as_text() {
1366        let formula = sheetkit_xml::worksheet::CellFormula {
1367            t: None,
1368            reference: None,
1369            si: None,
1370            value: Some("A1".to_string()),
1371        };
1372        let sst = SharedStringTable::new();
1373
1374        assert_eq!(
1375            parse_cell_type_value(CellTypeTag::Error, Some("=direct"), None, None, &sst, false,),
1376            CellValue::String("=direct".to_string())
1377        );
1378        assert_eq!(
1379            parse_cell_type_value(
1380                CellTypeTag::Error,
1381                Some("+cached"),
1382                Some(&formula),
1383                None,
1384                &sst,
1385                false,
1386            ),
1387            CellValue::Formula {
1388                expr: "A1".to_string(),
1389                result: Some(Box::new(CellValue::String("+cached".to_string()))),
1390            }
1391        );
1392    }
1393
1394    #[test]
1395    fn test_get_rows_with_inline_string() {
1396        let mut ws = WorksheetXml::default();
1397        ws.sheet_data = SheetData {
1398            rows: vec![Row {
1399                r: 1,
1400                spans: None,
1401                s: None,
1402                custom_format: None,
1403                ht: None,
1404                hidden: None,
1405                custom_height: None,
1406                outline_level: None,
1407                cells: vec![Cell {
1408                    r: "A1".try_into().unwrap(),
1409                    col: 1,
1410                    s: None,
1411                    t: CellTypeTag::InlineString,
1412                    v: None,
1413                    f: None,
1414                    is: Some(Box::new(sheetkit_xml::worksheet::InlineString {
1415                        t: Some("inline text".to_string()),
1416                        r: vec![],
1417                        r_ph: vec![],
1418                    })),
1419                }],
1420            }],
1421        };
1422
1423        let sst = SharedStringTable::new();
1424        let rows = get_rows(&ws, &sst, &[]).unwrap();
1425        assert_eq!(rows.len(), 1);
1426        assert_eq!(rows[0].1[0].1, CellValue::String("inline text".to_string()));
1427    }
1428
1429    // -- set_row_style / get_row_style tests --
1430
1431    #[test]
1432    fn test_get_row_style_default_is_zero() {
1433        let ws = WorksheetXml::default();
1434        assert_eq!(get_row_style(&ws, 1), 0);
1435    }
1436
1437    #[test]
1438    fn test_get_row_style_nonexistent_row_is_zero() {
1439        let ws = sample_ws();
1440        assert_eq!(get_row_style(&ws, 99), 0);
1441    }
1442
1443    #[test]
1444    fn test_set_row_style_applies_style() {
1445        let mut ws = sample_ws();
1446        set_row_style(&mut ws, 1, 5).unwrap();
1447
1448        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
1449        assert_eq!(row.s, Some(5));
1450        assert_eq!(row.custom_format, Some(true));
1451    }
1452
1453    #[test]
1454    fn test_set_row_style_applies_to_existing_cells() {
1455        let mut ws = sample_ws();
1456        set_row_style(&mut ws, 1, 3).unwrap();
1457
1458        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
1459        for cell in &row.cells {
1460            assert_eq!(cell.s, Some(3));
1461        }
1462    }
1463
1464    #[test]
1465    fn test_get_row_style_after_set() {
1466        let mut ws = sample_ws();
1467        set_row_style(&mut ws, 2, 7).unwrap();
1468        assert_eq!(get_row_style(&ws, 2), 7);
1469    }
1470
1471    #[test]
1472    fn test_set_row_style_creates_row_if_missing() {
1473        let mut ws = WorksheetXml::default();
1474        set_row_style(&mut ws, 5, 2).unwrap();
1475
1476        assert_eq!(ws.sheet_data.rows.len(), 1);
1477        assert_eq!(ws.sheet_data.rows[0].r, 5);
1478        assert_eq!(ws.sheet_data.rows[0].s, Some(2));
1479    }
1480
1481    #[test]
1482    fn test_set_row_style_zero_clears_custom_format() {
1483        let mut ws = sample_ws();
1484        set_row_style(&mut ws, 1, 5).unwrap();
1485        set_row_style(&mut ws, 1, 0).unwrap();
1486
1487        let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
1488        assert_eq!(row.s, Some(0));
1489        assert_eq!(row.custom_format, None);
1490    }
1491
1492    #[test]
1493    fn test_set_row_style_row_zero_returns_error() {
1494        let mut ws = WorksheetXml::default();
1495        let result = set_row_style(&mut ws, 0, 1);
1496        assert!(result.is_err());
1497    }
1498}