Skip to main content

sheetkit_core/
raw_transfer_v2.rs

1//! Read-direction buffer serializer v2 for bulk data transfer.
2//!
3//! Converts a `WorksheetXml` and `SharedStringTable` into a compact binary
4//! buffer with inline strings, eliminating the global string table that v1
5//! required. This allows incremental (row-by-row) decoding on the JS side
6//! without eagerly materializing all strings upfront.
7//!
8//! Binary format (little-endian throughout):
9//!
10//! ```text
11//! HEADER (16 bytes)
12//!   magic:     u32  = 0x534B5232 ("SKR2")
13//!   version:   u16  = 2
14//!   row_count: u32  = number of occupied rows
15//!   col_count: u16  = number of columns
16//!   flags:     u32  = bit 0: always 0 (v2 is always sparse)
17//!                      bits 16..31: min_col (1-based)
18//!
19//! ROW INDEX (row_count * 8 bytes; unoccupied rows are omitted)
20//!   per row: row_number (u32) + byte_offset (u32) into CELL DATA section
21//!   offset = 0xFFFFFFFF for empty rows
22//!
23//! CELL DATA (variable length)
24//!   per row: cell_count (u16) + cells
25//!   per cell: col (u16) + type (u8) + payload
26//!     0x00 (empty):  0 bytes
27//!     0x01 (number): 8 bytes (f64 LE)
28//!     0x02 (string): 4 bytes (len u32 LE) + N bytes (UTF-8)
29//!     0x03 (bool):   1 byte
30//!     0x04 (date):   8 bytes (f64 LE, Excel serial)
31//!     0x05 (error):  4 bytes (len u32 LE) + N bytes (UTF-8)
32//!     0x06 (formula): 4 bytes (len u32 LE) + N bytes (UTF-8, cached formula text)
33//!     0x07 (rich):   4 bytes (len u32 LE) + N bytes (UTF-8)
34//! ```
35
36use std::borrow::Cow;
37
38use crate::error::{Error, Result};
39use crate::raw_transfer::{inline_string_visible_text, RawValueBudget, SharedFormulaResolver};
40use crate::resource::ResourceDimension;
41use crate::sst::SharedStringTable;
42use crate::traversal::{
43    check_limit, checked_output_add, checked_output_mul, CheckedRect, TraversalLimits,
44    TraversalMode, TraversalOptions,
45};
46use crate::utils::cell_ref::cell_name_to_coordinates;
47use sheetkit_xml::worksheet::{CellTypeTag, WorksheetXml};
48
49pub const MAGIC_V2: u32 = 0x534B5232;
50pub const VERSION_V2: u16 = 2;
51pub const HEADER_SIZE: usize = 16;
52
53pub const TYPE_EMPTY: u8 = 0x00;
54pub const TYPE_NUMBER: u8 = 0x01;
55pub const TYPE_STRING: u8 = 0x02;
56pub const TYPE_BOOL: u8 = 0x03;
57pub const TYPE_DATE: u8 = 0x04;
58pub const TYPE_ERROR: u8 = 0x05;
59pub const TYPE_FORMULA: u8 = 0x06;
60pub const TYPE_RICH_STRING: u8 = 0x07;
61
62#[cfg(test)]
63const EMPTY_ROW_OFFSET: u32 = 0xFFFF_FFFF;
64
65/// A cell entry with inline string data (variable-length payload).
66struct CellEntryV2<'a> {
67    col: u16,
68    type_tag: u8,
69    payload: CellPayload<'a>,
70}
71
72/// Cell payload. Strings borrow from the worksheet or shared string table
73/// whenever possible; only derived text (shifted shared formulas, rich
74/// inline strings) is owned.
75enum CellPayload<'a> {
76    Empty,
77    Number(f64),
78    Bool(u8),
79    Str(Cow<'a, str>),
80}
81
82impl CellPayload<'_> {
83    fn byte_size(&self, limits: TraversalLimits) -> Result<u64> {
84        match self {
85            CellPayload::Empty => Ok(0),
86            CellPayload::Number(_) => Ok(8),
87            CellPayload::Bool(_) => Ok(1),
88            CellPayload::Str(s) => checked_output_add(4, s.len() as u64, limits),
89        }
90    }
91
92    fn write_to(&self, buf: &mut Vec<u8>) {
93        match self {
94            CellPayload::Empty => {}
95            CellPayload::Number(n) => {
96                buf.extend_from_slice(&n.to_le_bytes());
97            }
98            CellPayload::Bool(b) => {
99                buf.push(*b);
100            }
101            CellPayload::Str(s) => {
102                buf.extend_from_slice(&(s.len() as u32).to_le_bytes());
103                buf.extend_from_slice(s.as_bytes());
104            }
105        }
106    }
107}
108
109struct RowEntriesV2<'a> {
110    row_num: u32,
111    cells: Vec<CellEntryV2<'a>>,
112}
113
114impl RowEntriesV2<'_> {
115    /// Byte size of the cell data for this row (cell_count u16 + all cells).
116    fn byte_size(&self, limits: TraversalLimits) -> Result<u64> {
117        let mut size = 2u64;
118        for cell in &self.cells {
119            size = checked_output_add(size, 3, limits)?;
120            size = checked_output_add(size, cell.payload.byte_size(limits)?, limits)?;
121        }
122        Ok(size)
123    }
124}
125
126/// Serialize a worksheet's cell data into a compact binary buffer using v2 format.
127///
128/// The v2 format inlines all string data with each cell, eliminating the global
129/// string table. This enables incremental row-by-row decoding without eagerly
130/// decoding all strings.
131pub fn sheet_to_raw_buffer_v2(ws: &WorksheetXml, sst: &SharedStringTable) -> Result<Vec<u8>> {
132    sheet_to_raw_buffer_v2_with_options(ws, sst, TraversalOptions::default())
133}
134
135/// Serializes a worksheet in canonical v2 sparse format with finite options.
136pub fn sheet_to_raw_buffer_v2_with_options(
137    ws: &WorksheetXml,
138    sst: &SharedStringTable,
139    options: TraversalOptions,
140) -> Result<Vec<u8>> {
141    sheet_to_raw_buffer_v2_with_date_styles_and_options(ws, sst, &[], options)
142}
143
144/// Serialize a worksheet while promoting numeric cells that use date styles.
145pub fn sheet_to_raw_buffer_v2_with_date_styles(
146    ws: &WorksheetXml,
147    sst: &SharedStringTable,
148    style_is_date: &[bool],
149) -> Result<Vec<u8>> {
150    sheet_to_raw_buffer_v2_with_date_styles_and_options(
151        ws,
152        sst,
153        style_is_date,
154        TraversalOptions::default(),
155    )
156}
157
158/// Serializes a worksheet in canonical v2 sparse format with date styles.
159pub fn sheet_to_raw_buffer_v2_with_date_styles_and_options(
160    ws: &WorksheetXml,
161    sst: &SharedStringTable,
162    style_is_date: &[bool],
163    options: TraversalOptions,
164) -> Result<Vec<u8>> {
165    if options.mode() != TraversalMode::Sparse {
166        return Err(Error::Internal(
167            "raw transfer v2 supports sparse traversal only".to_string(),
168        ));
169    }
170    let rows = &ws.sheet_data.rows;
171    let limits = options.limits();
172
173    if rows.is_empty() {
174        return write_empty_buffer(limits);
175    }
176
177    let (min_row, max_row, min_col, max_col, total_cells) = scan_dimensions(ws, limits)?;
178
179    if total_cells == 0 {
180        return write_empty_buffer(limits);
181    }
182
183    let rect = CheckedRect::new_sparse(min_row, max_row, min_col, max_col, limits)?;
184    let occupied_rows = rows.iter().filter(|row| !row.cells.is_empty()).count() as u64;
185    check_limit(
186        ResourceDimension::RowCount,
187        limits.max_rows(),
188        occupied_rows,
189    )?;
190    check_limit(
191        ResourceDimension::CellCount,
192        limits.max_cells(),
193        total_cells,
194    )?;
195    let row_count = occupied_rows;
196    let col_count = rect.column_count();
197
198    let mut raw_value_budget = RawValueBudget::new(limits);
199    let shared_formulas = SharedFormulaResolver::new(ws, &mut raw_value_budget)?;
200    let mut cell_entries = collect_cell_entries_v2(
201        ws,
202        sst,
203        &shared_formulas,
204        &mut raw_value_budget,
205        min_col,
206        style_is_date,
207        limits,
208        occupied_rows,
209    )?;
210    cell_entries.sort_unstable_by_key(|row| row.row_num);
211
212    let flags: u32 = (min_col & 0xFFFF) << 16;
213
214    let row_index_size = checked_output_mul(row_count, 8, limits)?;
215    let mut row_sizes = Vec::new();
216    row_sizes
217        .try_reserve_exact(cell_entries.len())
218        .map_err(|_| Error::Internal("raw transfer v2 row size allocation failed".to_string()))?;
219    let cell_data_size = cell_entries.iter().try_fold(0u64, |total, row| {
220        let row_size = row.byte_size(limits)?;
221        row_sizes.push(row_size);
222        checked_output_add(total, row_size, limits)
223    })?;
224    let total_size = checked_output_add(
225        checked_output_add(HEADER_SIZE as u64, row_index_size, limits)?,
226        cell_data_size,
227        limits,
228    )?;
229    let total_size = usize::try_from(total_size)
230        .map_err(|_| Error::Internal("raw transfer v2 output is not addressable".to_string()))?;
231
232    validate_cell_data_v2(&cell_entries, cell_data_size)?;
233    validate_row_index_v2(&row_sizes, row_index_size)?;
234
235    let mut buf = Vec::new();
236    buf.try_reserve_exact(total_size)
237        .map_err(|_| Error::Internal("raw transfer v2 output allocation failed".to_string()))?;
238
239    buf.extend_from_slice(&MAGIC_V2.to_le_bytes());
240    buf.extend_from_slice(&VERSION_V2.to_le_bytes());
241    buf.extend_from_slice(&(row_count as u32).to_le_bytes());
242    buf.extend_from_slice(&(col_count as u16).to_le_bytes());
243    buf.extend_from_slice(&flags.to_le_bytes());
244
245    write_row_index_v2(&mut buf, &cell_entries, &row_sizes);
246    write_cell_data_v2(&mut buf, &cell_entries);
247    debug_assert_eq!(buf.len(), total_size);
248
249    Ok(buf)
250}
251
252fn write_empty_buffer(limits: TraversalLimits) -> Result<Vec<u8>> {
253    checked_output_add(0, HEADER_SIZE as u64, limits)?;
254    let mut buf = Vec::new();
255    buf.try_reserve_exact(HEADER_SIZE)
256        .map_err(|_| Error::Internal("raw transfer v2 output allocation failed".to_string()))?;
257    buf.extend_from_slice(&MAGIC_V2.to_le_bytes());
258    buf.extend_from_slice(&VERSION_V2.to_le_bytes());
259    buf.extend_from_slice(&0u32.to_le_bytes());
260    buf.extend_from_slice(&0u16.to_le_bytes());
261    buf.extend_from_slice(&0u32.to_le_bytes());
262    Ok(buf)
263}
264
265fn scan_dimensions(
266    ws: &WorksheetXml,
267    limits: TraversalLimits,
268) -> Result<(u32, u32, u32, u32, u64)> {
269    let mut min_row = u32::MAX;
270    let mut max_row = 0u32;
271    let mut min_col = u32::MAX;
272    let mut max_col = 0u32;
273    let mut total_cells = 0u64;
274
275    for row in &ws.sheet_data.rows {
276        if row.cells.is_empty() {
277            continue;
278        }
279        min_row = min_row.min(row.r);
280        max_row = max_row.max(row.r);
281        total_cells = total_cells
282            .checked_add(row.cells.len() as u64)
283            .ok_or_else(|| Error::Internal("raw transfer v2 cell count overflow".to_string()))?;
284        check_limit(
285            ResourceDimension::CellCount,
286            limits.max_cells(),
287            total_cells,
288        )?;
289        for cell in &row.cells {
290            let col = resolve_col(cell)?;
291            min_col = min_col.min(col);
292            max_col = max_col.max(col);
293        }
294    }
295
296    if total_cells == 0 {
297        return Ok((1, 1, 1, 1, 0));
298    }
299
300    Ok((min_row, max_row, min_col, max_col, total_cells))
301}
302
303fn resolve_col(cell: &sheetkit_xml::worksheet::Cell) -> Result<u32> {
304    if cell.col > 0 {
305        return Ok(cell.col);
306    }
307    let (col, _row) = cell_name_to_coordinates(cell.r.as_str())?;
308    Ok(col)
309}
310
311#[allow(clippy::too_many_arguments)]
312fn collect_cell_entries_v2<'a>(
313    ws: &'a WorksheetXml,
314    sst: &'a SharedStringTable,
315    shared_formulas: &'a SharedFormulaResolver,
316    raw_value_budget: &mut RawValueBudget,
317    min_col: u32,
318    style_is_date: &[bool],
319    limits: TraversalLimits,
320    occupied_rows: u64,
321) -> Result<Vec<RowEntriesV2<'a>>> {
322    let mut result = Vec::new();
323    let occupied_rows = usize::try_from(occupied_rows)
324        .map_err(|_| Error::Internal("raw transfer v2 row count is not addressable".to_string()))?;
325    result
326        .try_reserve_exact(occupied_rows)
327        .map_err(|_| Error::Internal("raw transfer v2 row allocation failed".to_string()))?;
328    let mut payload_bytes = 0u64;
329
330    for row in &ws.sheet_data.rows {
331        if row.cells.is_empty() {
332            continue;
333        }
334
335        check_limit(
336            ResourceDimension::ColumnCount,
337            limits.max_columns(),
338            row.cells.len() as u64,
339        )?;
340        let mut cells = Vec::new();
341        cells
342            .try_reserve_exact(row.cells.len())
343            .map_err(|_| Error::Internal("raw transfer v2 cell allocation failed".to_string()))?;
344        for cell in &row.cells {
345            let col = resolve_col(cell)?;
346            let relative_col = (col - min_col) as u16;
347            let (type_tag, payload) = encode_cell_value_v2(
348                cell,
349                sst,
350                shared_formulas,
351                style_is_date,
352                limits,
353                &mut payload_bytes,
354                raw_value_budget,
355            )?;
356            cells.push(CellEntryV2 {
357                col: relative_col,
358                type_tag,
359                payload,
360            });
361        }
362
363        result.push(RowEntriesV2 {
364            row_num: row.r,
365            cells,
366        });
367    }
368
369    Ok(result)
370}
371
372fn encode_cell_value_v2<'a>(
373    cell: &'a sheetkit_xml::worksheet::Cell,
374    sst: &'a SharedStringTable,
375    shared_formulas: &'a SharedFormulaResolver,
376    style_is_date: &[bool],
377    limits: TraversalLimits,
378    payload_bytes: &mut u64,
379    raw_value_budget: &mut RawValueBudget,
380) -> Result<(u8, CellPayload<'a>)> {
381    if cell.f.is_some() {
382        if let Some(formula_expr) = shared_formulas.formula_for(cell, raw_value_budget)? {
383            let formula_expr = bounded_string(formula_expr, limits, payload_bytes)?;
384            return Ok((TYPE_FORMULA, CellPayload::Str(formula_expr)));
385        }
386    }
387
388    match cell.t {
389        CellTypeTag::SharedString => {
390            if let Some(ref v) = cell.v {
391                if let Ok(sst_idx) = v.parse::<usize>() {
392                    let text = sst.get(sst_idx).unwrap_or("");
393                    if sst.get_rich_text(sst_idx).is_some() {
394                        return Ok((
395                            TYPE_RICH_STRING,
396                            CellPayload::Str(bounded_string(
397                                Cow::Borrowed(text),
398                                limits,
399                                payload_bytes,
400                            )?),
401                        ));
402                    }
403                    return Ok((
404                        TYPE_STRING,
405                        CellPayload::Str(bounded_string(
406                            Cow::Borrowed(text),
407                            limits,
408                            payload_bytes,
409                        )?),
410                    ));
411                }
412            }
413            Ok((TYPE_EMPTY, CellPayload::Empty))
414        }
415        CellTypeTag::Boolean => {
416            let b = if let Some(ref v) = cell.v {
417                if v == "1" || v.eq_ignore_ascii_case("true") {
418                    1u8
419                } else {
420                    0u8
421                }
422            } else {
423                0u8
424            };
425            Ok((TYPE_BOOL, CellPayload::Bool(b)))
426        }
427        CellTypeTag::Error => {
428            let error_text = cell.v.as_deref().unwrap_or("#VALUE!");
429            Ok((
430                TYPE_ERROR,
431                CellPayload::Str(bounded_string(
432                    Cow::Borrowed(error_text),
433                    limits,
434                    payload_bytes,
435                )?),
436            ))
437        }
438        CellTypeTag::InlineString => {
439            let text = if let Some(inline) = cell.is.as_deref() {
440                inline_string_visible_text(inline, raw_value_budget)?
441            } else {
442                Cow::Borrowed(cell.v.as_deref().unwrap_or(""))
443            };
444            Ok((
445                TYPE_STRING,
446                CellPayload::Str(bounded_string(text, limits, payload_bytes)?),
447            ))
448        }
449        CellTypeTag::Date => {
450            if let Some(ref v) = cell.v {
451                if let Ok(n) = v.parse::<f64>() {
452                    return Ok((TYPE_DATE, CellPayload::Number(n)));
453                }
454            }
455            Ok((TYPE_EMPTY, CellPayload::Empty))
456        }
457        CellTypeTag::FormulaString => {
458            if let Some(ref v) = cell.v {
459                return Ok((
460                    TYPE_STRING,
461                    CellPayload::Str(bounded_string(Cow::Borrowed(v), limits, payload_bytes)?),
462                ));
463            }
464            Ok((TYPE_EMPTY, CellPayload::Empty))
465        }
466        CellTypeTag::None | CellTypeTag::Number => {
467            if let Some(ref v) = cell.v {
468                if let Ok(n) = v.parse::<f64>() {
469                    let is_date = cell
470                        .s
471                        .and_then(|idx| style_is_date.get(idx as usize).copied())
472                        .unwrap_or(false);
473                    return Ok((
474                        if is_date { TYPE_DATE } else { TYPE_NUMBER },
475                        CellPayload::Number(n),
476                    ));
477                }
478            }
479            Ok((TYPE_EMPTY, CellPayload::Empty))
480        }
481    }
482}
483
484/// Charge one string payload against the output budget. The payload is
485/// borrowed, so no per-cell copy is made before the final buffer write.
486fn bounded_string<'a>(
487    value: Cow<'a, str>,
488    limits: TraversalLimits,
489    payload_bytes: &mut u64,
490) -> Result<Cow<'a, str>> {
491    *payload_bytes = checked_output_add(*payload_bytes, value.len() as u64, limits)?;
492    Ok(value)
493}
494
495/// Check every cell-data conversion before the single output write.
496fn validate_cell_data_v2(row_entries: &[RowEntriesV2<'_>], total: u64) -> Result<()> {
497    usize::try_from(total)
498        .map_err(|_| Error::Internal("raw transfer v2 cell data is too large".to_string()))?;
499    for row in row_entries {
500        u16::try_from(row.cells.len())
501            .map_err(|_| Error::Internal("raw transfer v2 row has too many cells".to_string()))?;
502    }
503    Ok(())
504}
505
506/// Check every row-index conversion before the single output write.
507fn validate_row_index_v2(row_sizes: &[u64], total: u64) -> Result<()> {
508    usize::try_from(total)
509        .map_err(|_| Error::Internal("raw transfer v2 row index is too large".to_string()))?;
510    let mut byte_offset = 0u32;
511    for row_size in row_sizes {
512        let row_size = u32::try_from(*row_size)
513            .map_err(|_| Error::Internal("raw transfer v2 row is too large".to_string()))?;
514        byte_offset = byte_offset
515            .checked_add(row_size)
516            .ok_or_else(|| Error::Internal("raw transfer v2 offset overflow".to_string()))?;
517    }
518    Ok(())
519}
520
521/// Write the row index. Conversions were checked by [`validate_row_index_v2`].
522fn write_row_index_v2(buf: &mut Vec<u8>, row_entries: &[RowEntriesV2<'_>], row_sizes: &[u64]) {
523    let mut byte_offset = 0u32;
524    for (row, row_size) in row_entries.iter().zip(row_sizes) {
525        buf.extend_from_slice(&row.row_num.to_le_bytes());
526        buf.extend_from_slice(&byte_offset.to_le_bytes());
527        byte_offset = byte_offset.wrapping_add(*row_size as u32);
528    }
529}
530
531/// Write the cell data. Conversions were checked by [`validate_cell_data_v2`].
532fn write_cell_data_v2(buf: &mut Vec<u8>, row_entries: &[RowEntriesV2<'_>]) {
533    for row in row_entries {
534        buf.extend_from_slice(&(row.cells.len() as u16).to_le_bytes());
535        for cell in &row.cells {
536            buf.extend_from_slice(&cell.col.to_le_bytes());
537            buf.push(cell.type_tag);
538            cell.payload.write_to(buf);
539        }
540    }
541}
542
543#[cfg(test)]
544#[allow(clippy::field_reassign_with_default)]
545mod tests {
546    use super::*;
547    use sheetkit_xml::shared_strings::{R, T};
548    use sheetkit_xml::worksheet::{
549        Cell, CellFormula, CellTypeTag, CompactCellRef, InlineString, Row, SheetData, WorksheetXml,
550    };
551
552    fn make_cell(col_ref: &str, col_num: u32, t: CellTypeTag, v: Option<&str>) -> Cell {
553        Cell {
554            r: CompactCellRef::new(col_ref).unwrap(),
555            col: col_num,
556            s: None,
557            t,
558            v: v.map(|s| s.to_string()),
559            f: None,
560            is: None,
561        }
562    }
563
564    fn make_row(row_num: u32, cells: Vec<Cell>) -> Row {
565        Row {
566            r: row_num,
567            spans: None,
568            s: None,
569            custom_format: None,
570            ht: None,
571            hidden: None,
572            custom_height: None,
573            outline_level: None,
574            cells,
575        }
576    }
577
578    fn make_worksheet(rows: Vec<Row>) -> WorksheetXml {
579        let mut ws = WorksheetXml::default();
580        ws.sheet_data = SheetData { rows };
581        ws
582    }
583
584    fn make_sst(strings: &[&str]) -> SharedStringTable {
585        let mut sst = SharedStringTable::new();
586        for s in strings {
587            sst.add(s);
588        }
589        sst
590    }
591
592    fn read_u32_le(buf: &[u8], offset: usize) -> u32 {
593        u32::from_le_bytes(buf[offset..offset + 4].try_into().unwrap())
594    }
595
596    fn read_u16_le(buf: &[u8], offset: usize) -> u16 {
597        u16::from_le_bytes(buf[offset..offset + 2].try_into().unwrap())
598    }
599
600    fn read_f64_le(buf: &[u8], offset: usize) -> f64 {
601        f64::from_le_bytes(buf[offset..offset + 8].try_into().unwrap())
602    }
603
604    fn read_inline_string(buf: &[u8], offset: usize) -> (String, usize) {
605        let len = read_u32_le(buf, offset) as usize;
606        let s = std::str::from_utf8(&buf[offset + 4..offset + 4 + len])
607            .unwrap()
608            .to_string();
609        (s, 4 + len)
610    }
611
612    /// Parse v2 buffer cell data for a single row at the given absolute offset.
613    /// Returns vec of (col, type_tag, value_description).
614    fn read_v2_row_cells(buf: &[u8], abs_offset: usize) -> Vec<(u16, u8, String)> {
615        let cell_count = read_u16_le(buf, abs_offset) as usize;
616        let mut pos = abs_offset + 2;
617        let mut result = Vec::with_capacity(cell_count);
618
619        for _ in 0..cell_count {
620            let col = read_u16_le(buf, pos);
621            let type_tag = buf[pos + 2];
622            pos += 3;
623
624            let val = match type_tag {
625                TYPE_EMPTY => String::new(),
626                TYPE_NUMBER | TYPE_DATE => {
627                    let n = read_f64_le(buf, pos);
628                    pos += 8;
629                    format!("{n}")
630                }
631                TYPE_BOOL => {
632                    let b = buf[pos];
633                    pos += 1;
634                    format!("{b}")
635                }
636                TYPE_STRING | TYPE_ERROR | TYPE_FORMULA | TYPE_RICH_STRING => {
637                    let (s, consumed) = read_inline_string(buf, pos);
638                    pos += consumed;
639                    s
640                }
641                _ => panic!("unknown type tag: {type_tag}"),
642            };
643
644            result.push((col, type_tag, val));
645        }
646
647        result
648    }
649
650    #[test]
651    fn test_empty_sheet() {
652        let ws = make_worksheet(vec![]);
653        let sst = SharedStringTable::new();
654        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
655
656        assert_eq!(buf.len(), HEADER_SIZE);
657        assert_eq!(read_u32_le(&buf, 0), MAGIC_V2);
658        assert_eq!(read_u16_le(&buf, 4), VERSION_V2);
659        assert_eq!(read_u32_le(&buf, 6), 0);
660        assert_eq!(read_u16_le(&buf, 10), 0);
661        assert_eq!(read_u32_le(&buf, 12), 0);
662    }
663
664    #[test]
665    fn test_single_number_cell() {
666        let ws = make_worksheet(vec![make_row(
667            1,
668            vec![make_cell("A1", 1, CellTypeTag::None, Some("42.5"))],
669        )]);
670        let sst = SharedStringTable::new();
671        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
672
673        assert_eq!(read_u32_le(&buf, 0), MAGIC_V2);
674        assert_eq!(read_u32_le(&buf, 6), 1); // row_count
675        assert_eq!(read_u16_le(&buf, 10), 1); // col_count
676
677        let row_index_start = HEADER_SIZE;
678        let row1_num = read_u32_le(&buf, row_index_start);
679        let row1_offset = read_u32_le(&buf, row_index_start + 4);
680        assert_eq!(row1_num, 1);
681        assert_ne!(row1_offset, EMPTY_ROW_OFFSET);
682
683        let cell_data_start = HEADER_SIZE + 8;
684        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
685        assert_eq!(cells.len(), 1);
686        assert_eq!(cells[0].0, 0); // col 0 (relative)
687        assert_eq!(cells[0].1, TYPE_NUMBER);
688        assert_eq!(cells[0].2, "42.5");
689    }
690
691    #[test]
692    fn test_string_cell_sst() {
693        let sst = make_sst(&["Hello", "World"]);
694        let ws = make_worksheet(vec![make_row(
695            1,
696            vec![make_cell("A1", 1, CellTypeTag::SharedString, Some("1"))],
697        )]);
698        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
699
700        let cell_data_start = HEADER_SIZE + 8;
701        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
702        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
703
704        assert_eq!(cells.len(), 1);
705        assert_eq!(cells[0].1, TYPE_STRING);
706        assert_eq!(cells[0].2, "World"); // SST index 1 = "World"
707    }
708
709    #[test]
710    fn test_bool_cell() {
711        let sst = SharedStringTable::new();
712        let ws = make_worksheet(vec![make_row(
713            1,
714            vec![
715                make_cell("A1", 1, CellTypeTag::Boolean, Some("1")),
716                make_cell("B1", 2, CellTypeTag::Boolean, Some("0")),
717            ],
718        )]);
719        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
720
721        let cell_data_start = HEADER_SIZE + 8;
722        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
723        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
724
725        assert_eq!(cells.len(), 2);
726        assert_eq!(cells[0].1, TYPE_BOOL);
727        assert_eq!(cells[0].2, "1");
728        assert_eq!(cells[1].1, TYPE_BOOL);
729        assert_eq!(cells[1].2, "0");
730    }
731
732    #[test]
733    fn test_error_cell() {
734        let sst = SharedStringTable::new();
735        let ws = make_worksheet(vec![make_row(
736            1,
737            vec![make_cell("A1", 1, CellTypeTag::Error, Some("#DIV/0!"))],
738        )]);
739        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
740
741        let cell_data_start = HEADER_SIZE + 8;
742        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
743        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
744
745        assert_eq!(cells.len(), 1);
746        assert_eq!(cells[0].1, TYPE_ERROR);
747        assert_eq!(cells[0].2, "#DIV/0!");
748    }
749
750    #[test]
751    fn test_formula_cell() {
752        let sst = SharedStringTable::new();
753        let mut cell = make_cell("A1", 1, CellTypeTag::None, Some("84"));
754        cell.f = Some(Box::new(CellFormula {
755            t: None,
756            reference: None,
757            si: None,
758            value: Some("A2+B2".to_string()),
759        }));
760        let ws = make_worksheet(vec![make_row(1, vec![cell])]);
761        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
762
763        let cell_data_start = HEADER_SIZE + 8;
764        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
765        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
766
767        assert_eq!(cells.len(), 1);
768        assert_eq!(cells[0].1, TYPE_FORMULA);
769        assert_eq!(cells[0].2, "A2+B2");
770    }
771
772    #[test]
773    fn test_shared_formula_followers_shift_relative_references() {
774        let sst = SharedStringTable::new();
775        let mut master = make_cell("B2", 2, CellTypeTag::None, Some("1"));
776        master.f = Some(Box::new(CellFormula {
777            t: Some("shared".to_string()),
778            reference: Some("B2:C3".to_string()),
779            si: Some(7),
780            value: Some("A2+$A$1".to_string()),
781        }));
782        let mut across = make_cell("C2", 3, CellTypeTag::None, Some("2"));
783        across.f = Some(Box::new(CellFormula {
784            t: Some("shared".to_string()),
785            reference: None,
786            si: Some(7),
787            value: None,
788        }));
789        let mut down = make_cell("B3", 2, CellTypeTag::None, Some("3"));
790        down.f = Some(Box::new(CellFormula {
791            t: Some("shared".to_string()),
792            reference: None,
793            si: Some(7),
794            value: None,
795        }));
796        let ws = make_worksheet(vec![
797            make_row(2, vec![master, across]),
798            make_row(3, vec![down]),
799        ]);
800        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
801        let cell_data_start = HEADER_SIZE + 16;
802        let row2_offset = read_u32_le(&buf, HEADER_SIZE + 4);
803        let row3_offset = read_u32_le(&buf, HEADER_SIZE + 12);
804        let row2 = read_v2_row_cells(&buf, cell_data_start + row2_offset as usize);
805        let row3 = read_v2_row_cells(&buf, cell_data_start + row3_offset as usize);
806
807        assert_eq!(
808            row2,
809            vec![
810                (0, TYPE_FORMULA, "A2+$A$1".to_string()),
811                (1, TYPE_FORMULA, "B2+$A$1".to_string())
812            ]
813        );
814        assert_eq!(row3, vec![(0, TYPE_FORMULA, "A3+$A$1".to_string())]);
815    }
816
817    #[test]
818    fn v1_and_v2_match_for_budgeted_shared_formulas_and_inline_rich_text() {
819        let sst = SharedStringTable::new();
820        let mut master = make_cell("A1", 1, CellTypeTag::None, Some("1"));
821        master.f = Some(Box::new(CellFormula {
822            t: Some("shared".to_string()),
823            reference: Some("A1:B1".to_string()),
824            si: Some(12),
825            value: Some("A1+$A$1".to_string()),
826        }));
827        let mut follower = make_cell("B1", 2, CellTypeTag::None, Some("2"));
828        follower.f = Some(Box::new(CellFormula {
829            t: Some("shared".to_string()),
830            reference: None,
831            si: Some(12),
832            value: None,
833        }));
834        let mut rich = make_cell("C1", 3, CellTypeTag::InlineString, None);
835        rich.is = Some(Box::new(InlineString {
836            t: None,
837            r: vec![
838                R {
839                    r_pr: None,
840                    t: T {
841                        xml_space: None,
842                        value: "Rich".to_string(),
843                    },
844                },
845                R {
846                    r_pr: None,
847                    t: T {
848                        xml_space: None,
849                        value: " Text".to_string(),
850                    },
851                },
852            ],
853            r_ph: vec![],
854        }));
855        let ws = make_worksheet(vec![make_row(1, vec![master, follower, rich])]);
856
857        let v1 = crate::raw_transfer::sheet_to_raw_buffer(&ws, &sst).unwrap();
858        let v2 = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
859
860        assert_eq!(
861            crate::raw_transfer_write::raw_buffer_to_cells(&v1).unwrap(),
862            crate::raw_transfer_write::raw_buffer_to_cells(&v2).unwrap()
863        );
864    }
865
866    #[test]
867    fn test_shared_formula_without_master_uses_cached_value_or_empty() {
868        let sst = SharedStringTable::new();
869        let mut cached = make_cell("A1", 1, CellTypeTag::None, Some("17"));
870        cached.f = Some(Box::new(CellFormula {
871            t: Some("shared".to_string()),
872            reference: None,
873            si: Some(99),
874            value: None,
875        }));
876        let mut missing = make_cell("B1", 2, CellTypeTag::None, None);
877        missing.f = Some(Box::new(CellFormula {
878            t: Some("shared".to_string()),
879            reference: None,
880            si: Some(99),
881            value: None,
882        }));
883        let ws = make_worksheet(vec![make_row(1, vec![cached, missing])]);
884        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
885        let cells = read_v2_row_cells(&buf, HEADER_SIZE + 8);
886
887        assert_eq!(cells[0], (0, TYPE_NUMBER, "17".to_string()));
888        assert_eq!(cells[1], (1, TYPE_EMPTY, String::new()));
889    }
890
891    #[test]
892    fn test_inline_string_cell() {
893        let sst = SharedStringTable::new();
894        let mut cell = make_cell("A1", 1, CellTypeTag::InlineString, None);
895        cell.is = Some(Box::new(InlineString {
896            t: Some("Inline Text".to_string()),
897            r: vec![],
898            r_ph: vec![],
899        }));
900        let ws = make_worksheet(vec![make_row(1, vec![cell])]);
901        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
902
903        let cell_data_start = HEADER_SIZE + 8;
904        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
905        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
906
907        assert_eq!(cells.len(), 1);
908        assert_eq!(cells[0].1, TYPE_STRING);
909        assert_eq!(cells[0].2, "Inline Text");
910    }
911
912    #[test]
913    fn test_inline_string_preserves_escaped_visible_text() {
914        let sst = SharedStringTable::new();
915        let mut cell = make_cell("A1", 1, CellTypeTag::InlineString, None);
916        cell.is = Some(Box::new(InlineString {
917            t: Some("A < B & C".to_string()),
918            r: vec![],
919            r_ph: vec![],
920        }));
921        let ws = make_worksheet(vec![make_row(1, vec![cell])]);
922        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
923        let cells = read_v2_row_cells(&buf, HEADER_SIZE + 8);
924
925        assert_eq!(cells, vec![(0, TYPE_STRING, "A < B & C".to_string())]);
926    }
927
928    #[test]
929    fn test_inline_rich_text_concatenates_runs_without_phonetics() {
930        let sst = SharedStringTable::new();
931        let mut cell = make_cell("A1", 1, CellTypeTag::InlineString, None);
932        cell.is = Some(Box::new(InlineString {
933            t: None,
934            r: vec![
935                R {
936                    r_pr: None,
937                    t: T {
938                        xml_space: None,
939                        value: "Bold".to_string(),
940                    },
941                },
942                R {
943                    r_pr: None,
944                    t: T {
945                        xml_space: Some("preserve".to_string()),
946                        value: " Text & More".to_string(),
947                    },
948                },
949            ],
950            r_ph: vec![sheetkit_xml::worksheet::PhoneticRun {
951                sb: Some(0),
952                eb: Some(4),
953                value: "phonetic".to_string(),
954            }],
955        }));
956        let ws = make_worksheet(vec![make_row(1, vec![cell])]);
957        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
958        let cells = read_v2_row_cells(&buf, HEADER_SIZE + 8);
959
960        assert_eq!(
961            cells,
962            vec![(0, TYPE_STRING, "Bold Text & More".to_string())]
963        );
964    }
965
966    #[test]
967    fn test_date_cell() {
968        let sst = SharedStringTable::new();
969        let ws = make_worksheet(vec![make_row(
970            1,
971            vec![make_cell("A1", 1, CellTypeTag::Date, Some("44927.0"))],
972        )]);
973        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
974
975        let cell_data_start = HEADER_SIZE + 8;
976        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
977        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
978
979        assert_eq!(cells.len(), 1);
980        assert_eq!(cells[0].1, TYPE_DATE);
981        let val: f64 = cells[0].2.parse().unwrap();
982        assert!((val - 44927.0).abs() < f64::EPSILON);
983    }
984
985    #[test]
986    fn test_mixed_types_row() {
987        let sst = make_sst(&["Hello"]);
988        let ws = make_worksheet(vec![make_row(
989            1,
990            vec![
991                make_cell("A1", 1, CellTypeTag::None, Some("3.14")),
992                make_cell("B1", 2, CellTypeTag::SharedString, Some("0")),
993                make_cell("C1", 3, CellTypeTag::Boolean, Some("1")),
994            ],
995        )]);
996        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
997
998        let cell_data_start = HEADER_SIZE + 8;
999        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1000        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1001
1002        assert_eq!(cells.len(), 3);
1003        assert_eq!(cells[0].1, TYPE_NUMBER);
1004        assert_eq!(cells[1].1, TYPE_STRING);
1005        assert_eq!(cells[1].2, "Hello");
1006        assert_eq!(cells[2].1, TYPE_BOOL);
1007    }
1008
1009    #[test]
1010    fn test_sparse_rows_with_gaps() {
1011        let sst = SharedStringTable::new();
1012        let rows = vec![
1013            make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1014            make_row(
1015                100,
1016                vec![make_cell("T100", 20, CellTypeTag::None, Some("2"))],
1017            ),
1018        ];
1019        let ws = make_worksheet(rows);
1020        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1021
1022        let row_count = read_u32_le(&buf, 6) as usize;
1023        assert_eq!(row_count, 2);
1024        let col_count = read_u16_le(&buf, 10) as usize;
1025        assert_eq!(col_count, 20);
1026
1027        // Verify row 1 has data
1028        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1029        assert_ne!(row1_offset, EMPTY_ROW_OFFSET);
1030
1031        // Verify the second entry preserves absolute row 100.
1032        assert_eq!(read_u32_le(&buf, HEADER_SIZE + 8), 100);
1033        let row100_offset = read_u32_le(&buf, HEADER_SIZE + 12);
1034        assert_ne!(row100_offset, EMPTY_ROW_OFFSET);
1035    }
1036
1037    #[test]
1038    fn canonical_sparse_size_depends_on_occupied_rows_not_row_distance() {
1039        let sst = SharedStringTable::new();
1040        let near = make_worksheet(vec![
1041            make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1042            make_row(2, vec![make_cell("A2", 1, CellTypeTag::None, Some("2"))]),
1043        ]);
1044        let far = make_worksheet(vec![
1045            make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1046            make_row(
1047                1_048_576,
1048                vec![make_cell("A1048576", 1, CellTypeTag::None, Some("2"))],
1049            ),
1050        ]);
1051
1052        let near_buffer = sheet_to_raw_buffer_v2(&near, &sst).unwrap();
1053        let far_buffer = sheet_to_raw_buffer_v2(&far, &sst).unwrap();
1054
1055        assert_eq!(read_u32_le(&near_buffer, 6), 2);
1056        assert_eq!(read_u32_le(&far_buffer, 6), 2);
1057        assert_eq!(near_buffer.len(), far_buffer.len());
1058        assert_eq!(read_u32_le(&far_buffer, HEADER_SIZE + 8), 1_048_576);
1059        let decoded = crate::raw_transfer_write::raw_buffer_to_cells(&far_buffer).unwrap();
1060        assert_eq!(decoded[0].0, 1);
1061        assert_eq!(decoded[1].0, 1_048_576);
1062    }
1063
1064    #[test]
1065    fn canonical_sparse_enforces_exact_output_boundary() {
1066        let sst = SharedStringTable::new();
1067        let ws = make_worksheet(vec![make_row(
1068            1,
1069            vec![make_cell(
1070                "A1",
1071                1,
1072                CellTypeTag::InlineString,
1073                Some("payload"),
1074            )],
1075        )]);
1076        let baseline = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1077        let exact = TraversalLimits::new(1, 1, 1, baseline.len() as u64).unwrap();
1078        sheet_to_raw_buffer_v2_with_options(
1079            &ws,
1080            &sst,
1081            TraversalOptions::default().with_limits(exact),
1082        )
1083        .unwrap();
1084
1085        let error = sheet_to_raw_buffer_v2_with_options(
1086            &ws,
1087            &sst,
1088            TraversalOptions::default()
1089                .with_limits(TraversalLimits::new(1, 1, 1, baseline.len() as u64 - 1).unwrap()),
1090        )
1091        .unwrap_err();
1092        let Error::ResourceLimitExceeded(metadata) = error else {
1093            panic!("expected resource limit error");
1094        };
1095        assert_eq!(metadata.dimension(), ResourceDimension::OutputBytes);
1096        assert_eq!(metadata.observed(), baseline.len() as u64);
1097    }
1098
1099    #[test]
1100    fn test_row_index_entries() {
1101        let sst = SharedStringTable::new();
1102        let ws = make_worksheet(vec![
1103            make_row(1, vec![make_cell("A1", 1, CellTypeTag::None, Some("1"))]),
1104            make_row(3, vec![make_cell("A3", 1, CellTypeTag::None, Some("3"))]),
1105        ]);
1106        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1107
1108        let row_count = read_u32_le(&buf, 6) as usize;
1109        assert_eq!(row_count, 2);
1110
1111        let row1_num = read_u32_le(&buf, HEADER_SIZE);
1112        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1113        assert_eq!(row1_num, 1);
1114        assert_ne!(row1_offset, EMPTY_ROW_OFFSET);
1115
1116        let row3_num = read_u32_le(&buf, HEADER_SIZE + 8);
1117        let row3_offset = read_u32_le(&buf, HEADER_SIZE + 12);
1118        assert_eq!(row3_num, 3);
1119        assert_ne!(row3_offset, EMPTY_ROW_OFFSET);
1120    }
1121
1122    #[test]
1123    fn test_header_format() {
1124        let sst = SharedStringTable::new();
1125        let ws = make_worksheet(vec![
1126            make_row(
1127                2,
1128                vec![
1129                    make_cell("B2", 2, CellTypeTag::None, Some("10")),
1130                    make_cell("D2", 4, CellTypeTag::None, Some("20")),
1131                ],
1132            ),
1133            make_row(5, vec![make_cell("C5", 3, CellTypeTag::None, Some("30"))]),
1134        ]);
1135        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1136
1137        assert_eq!(read_u32_le(&buf, 0), MAGIC_V2);
1138        assert_eq!(read_u16_le(&buf, 4), VERSION_V2);
1139        let row_count = read_u32_le(&buf, 6);
1140        assert_eq!(row_count, 2, "only occupied rows are indexed");
1141        let col_count = read_u16_le(&buf, 10);
1142        assert_eq!(col_count, 3, "cols B-D = 3 columns");
1143    }
1144
1145    #[test]
1146    fn test_no_string_table_section() {
1147        let sst = make_sst(&["Alpha", "Beta"]);
1148        let ws = make_worksheet(vec![make_row(
1149            1,
1150            vec![
1151                make_cell("A1", 1, CellTypeTag::SharedString, Some("0")),
1152                make_cell("B1", 2, CellTypeTag::SharedString, Some("1")),
1153            ],
1154        )]);
1155        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1156
1157        // v2 has no string table section: after header + row_index comes cell data directly
1158        let cell_data_start = HEADER_SIZE + 8; // 1 row * 8 bytes
1159        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1160        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1161
1162        assert_eq!(cells.len(), 2);
1163        assert_eq!(cells[0].1, TYPE_STRING);
1164        assert_eq!(cells[0].2, "Alpha");
1165        assert_eq!(cells[1].1, TYPE_STRING);
1166        assert_eq!(cells[1].2, "Beta");
1167    }
1168
1169    #[test]
1170    fn test_large_string_inline() {
1171        let sst = SharedStringTable::new();
1172        let long_str = "A".repeat(10000);
1173        let ws = make_worksheet(vec![make_row(
1174            1,
1175            vec![make_cell(
1176                "A1",
1177                1,
1178                CellTypeTag::InlineString,
1179                Some(&long_str),
1180            )],
1181        )]);
1182        // InlineString uses `is` field; set it via the cell is field
1183        // Actually InlineString with v.as_deref() fallback will use `v` if `is` is None
1184        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1185
1186        let cell_data_start = HEADER_SIZE + 8;
1187        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1188        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1189
1190        assert_eq!(cells.len(), 1);
1191        assert_eq!(cells[0].1, TYPE_STRING);
1192        assert_eq!(cells[0].2, long_str);
1193    }
1194
1195    #[test]
1196    fn test_formula_string_type() {
1197        let sst = SharedStringTable::new();
1198        let ws = make_worksheet(vec![make_row(
1199            1,
1200            vec![make_cell(
1201                "A1",
1202                1,
1203                CellTypeTag::FormulaString,
1204                Some("computed"),
1205            )],
1206        )]);
1207        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1208
1209        let cell_data_start = HEADER_SIZE + 8;
1210        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1211        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1212
1213        assert_eq!(cells[0].1, TYPE_STRING);
1214        assert_eq!(cells[0].2, "computed");
1215    }
1216
1217    #[test]
1218    fn test_rich_string_from_sst() {
1219        use crate::rich_text::RichTextRun;
1220
1221        let mut sst = SharedStringTable::new();
1222        sst.add("plain");
1223        sst.add_rich_text(&[
1224            RichTextRun {
1225                text: "Bold".to_string(),
1226                font: None,
1227                size: None,
1228                bold: true,
1229                italic: false,
1230                color: None,
1231            },
1232            RichTextRun {
1233                text: " Normal".to_string(),
1234                font: None,
1235                size: None,
1236                bold: false,
1237                italic: false,
1238                color: None,
1239            },
1240        ]);
1241
1242        let ws = make_worksheet(vec![make_row(
1243            1,
1244            vec![make_cell("A1", 1, CellTypeTag::SharedString, Some("1"))],
1245        )]);
1246        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1247
1248        let cell_data_start = HEADER_SIZE + 8;
1249        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1250        let cells = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1251
1252        assert_eq!(cells[0].1, TYPE_RICH_STRING);
1253        assert_eq!(cells[0].2, "Bold Normal");
1254    }
1255
1256    #[test]
1257    fn test_multiple_rows_multiple_types() {
1258        let sst = make_sst(&["Hello", "World"]);
1259        let ws = make_worksheet(vec![
1260            make_row(
1261                1,
1262                vec![
1263                    make_cell("A1", 1, CellTypeTag::None, Some("42")),
1264                    make_cell("B1", 2, CellTypeTag::SharedString, Some("0")),
1265                ],
1266            ),
1267            make_row(
1268                2,
1269                vec![
1270                    make_cell("A2", 1, CellTypeTag::Boolean, Some("1")),
1271                    make_cell("B2", 2, CellTypeTag::Error, Some("#N/A")),
1272                ],
1273            ),
1274        ]);
1275        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1276
1277        let row_count = read_u32_le(&buf, 6) as usize;
1278        assert_eq!(row_count, 2);
1279
1280        let cell_data_start = HEADER_SIZE + row_count * 8;
1281
1282        let row1_offset = read_u32_le(&buf, HEADER_SIZE + 4);
1283        let cells1 = read_v2_row_cells(&buf, cell_data_start + row1_offset as usize);
1284        assert_eq!(cells1.len(), 2);
1285        assert_eq!(cells1[0].1, TYPE_NUMBER);
1286        assert_eq!(cells1[1].1, TYPE_STRING);
1287        assert_eq!(cells1[1].2, "Hello");
1288
1289        let row2_offset = read_u32_le(&buf, HEADER_SIZE + 8 + 4);
1290        let cells2 = read_v2_row_cells(&buf, cell_data_start + row2_offset as usize);
1291        assert_eq!(cells2.len(), 2);
1292        assert_eq!(cells2[0].1, TYPE_BOOL);
1293        assert_eq!(cells2[1].1, TYPE_ERROR);
1294        assert_eq!(cells2[1].2, "#N/A");
1295    }
1296
1297    #[test]
1298    fn test_cell_without_col_uses_ref_parsing() {
1299        let sst = SharedStringTable::new();
1300        let mut cell = make_cell("C5", 0, CellTypeTag::None, Some("42"));
1301        cell.col = 0;
1302        let ws = make_worksheet(vec![make_row(5, vec![cell])]);
1303        let buf = sheet_to_raw_buffer_v2(&ws, &sst).unwrap();
1304
1305        let row_count = read_u32_le(&buf, 6);
1306        assert_eq!(row_count, 1);
1307        let col_count = read_u16_le(&buf, 10);
1308        assert_eq!(col_count, 1);
1309    }
1310}