html-to-markdown 3.4.0 → 3.6.0.pre.rc.23

data/vendor/html-to-markdown-rs/tests/tables_test.rs

@@ -1,743 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use html_to_markdown_rs::ConversionOptions;
-
-#[test]
-fn test_basic_table() {
-    let html = r"<table>
-    <tr><th>Header 1</th><th>Header 2</th></tr>
-    <tr><td>Cell 1</td><td>Cell 2</td></tr>
-    </table>";
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Header 1"), "header row missing: {result}");
-    assert!(result.contains("| Header 2"), "header row missing: {result}");
-    assert!(result.contains("| Cell 1"), "cell row missing: {result}");
-    assert!(result.contains("| Cell 2"), "cell row missing: {result}");
-    // Separator must exist; dashes are padded to column width so just check presence.
-    assert!(result.contains("| ---"), "separator row missing: {result}");
-}
-
-#[test]
-fn test_table_with_sections() {
-    let html = r"<table>
-        <thead>
-            <tr><th>Name</th><th>Age</th></tr>
-        </thead>
-        <tbody>
-            <tr><td>John</td><td>25</td></tr>
-            <tr><td>Jane</td><td>30</td></tr>
-        </tbody>
-        <tfoot>
-            <tr><td>Total</td><td>2</td></tr>
-        </tfoot>
-    </table>";
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Name"), "Name column missing: {result}");
-    assert!(result.contains("| Age"), "Age column missing: {result}");
-    assert!(result.contains("| John"), "John row missing: {result}");
-    assert!(result.contains("| 25"), "25 cell missing: {result}");
-    assert!(result.contains("| Jane"), "Jane row missing: {result}");
-    assert!(result.contains("| 30"), "30 cell missing: {result}");
-    assert!(result.contains("| Total"), "Total row missing: {result}");
-    assert!(result.contains("| 2"), "2 cell missing: {result}");
-}
-
-#[test]
-fn test_table_caption() {
-    let html = r"<table><caption>Table Caption</caption><tr><td>Data</td></tr></table>";
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("*Table Caption*"));
-    assert!(result.contains("| Data |"));
-}
-
-#[test]
-fn test_table_rowspan() {
-    // Test table rowspan with multi-line content in cells
-    // With br_in_tables enabled, divs are converted to br separators
-    let html = r#"<table>
-<tr><th>Header 1</th><th>Header 2</th></tr>
-<tr><td rowspan="2">Spanning cell</td><td>
-    <div>First row content</div>
-    <div>Second line</div>
-</td></tr>
-<tr><td>
-    <div>Next row</div>
-    <div>More content</div>
-</td></tr>
-</table>"#;
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Content should be present; exact br format may vary
-    assert!(
-        result.contains("Spanning cell")
-            && result.contains("First row content")
-            && result.contains("Second line")
-            && result.contains("Next row")
-            && result.contains("More content"),
-        "All rowspan content should be present: {result}"
-    );
-}
-
-#[test]
-fn test_table_colspan() {
-    let html = r#"<table>
-<tr><th colspan="2">Wide Header</th></tr>
-<tr><td>Cell 1</td><td>Cell 2</td></tr>
-</table>"#;
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Wide Header"), "Wide Header missing: {result}");
-    assert!(result.contains("| Cell 1"), "Cell 1 missing: {result}");
-    assert!(result.contains("| Cell 2"), "Cell 2 missing: {result}");
-}
-
-#[test]
-fn test_table_cell_multiline_content() {
-    // Test table cells with multiple divs (multiline content)
-    // With br_in_tables enabled, divs should be separated by breaks
-    let html = r"<table>
-<tr><th>Header 1</th><th>Header 2</th></tr>
-<tr><td>Cell 3</td><td>
-    <div>Cell 4-1</div>
-    <div>Cell 4-2</div>
-</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All content should be present
-    assert!(
-        result.contains("Header 1")
-            && result.contains("Header 2")
-            && result.contains("Cell 3")
-            && result.contains("Cell 4-1")
-            && result.contains("Cell 4-2"),
-        "All cell content should be present: {result}"
-    );
-}
-
-#[test]
-fn test_table_first_row_in_tbody_without_header() {
-    let html = r"<table>
-    <tbody>
-        <tr><td>Cell 1</td><td>Cell 2</td></tr>
-    </tbody>
-    </table>";
-
-    let result = convert(html, None).unwrap();
-    // Column width is 6 chars ("Cell 1"/"Cell 2"), so separator has 6 dashes.
-    assert!(result.contains("| Cell 1"), "Cell 1 missing: {result}");
-    assert!(result.contains("| Cell 2"), "Cell 2 missing: {result}");
-    assert!(result.contains("| ---"), "separator missing: {result}");
-}
-
-#[test]
-fn test_tbody_only() {
-    let html = "<table><tbody><tr><td>Data</td></tr></tbody></table>";
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Data |"));
-}
-
-#[test]
-fn test_tfoot_basic() {
-    let html = "<table><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Data</td></tr></tbody></table>";
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Footer"), "Footer cell missing: {result}");
-    assert!(result.contains("| Data"), "Data cell missing: {result}");
-}
-
-#[test]
-fn test_caption_with_formatting() {
-    let html = r"<table><caption>Sales <strong>Report</strong> 2023</caption><tr><td>Data</td></tr></table>";
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("*Sales **Report** 2023*"));
-}
-
-#[test]
-fn test_table_with_links() {
-    let html = r#"<table>
-<tr><th>Name</th><th>Website</th></tr>
-<tr><td>Example</td><td><a href="https://example.com">Link</a></td></tr>
-</table>"#;
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Name"), "Name column missing: {result}");
-    assert!(result.contains("| Website"), "Website column missing: {result}");
-    assert!(result.contains("[Link](https://example.com)"), "link missing: {result}");
-}
-
-#[test]
-fn test_table_with_code() {
-    let html = r"<table>
-<tr><th>Command</th></tr>
-<tr><td><code>ls -la</code></td></tr>
-</table>";
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Command"), "Command column missing: {result}");
-    assert!(result.contains("`ls -la`"), "code cell missing: {result}");
-}
-
-#[test]
-fn test_table_empty_cells() {
-    let html = r"<table>
-<tr><td>Data</td><td></td></tr>
-</table>";
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Data |  |"));
-}
-
-#[test]
-fn test_table_single_column() {
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Cell 1</td></tr>
-<tr><td>Cell 2</td></tr>
-</table>";
-
-    let result = convert(html, None).unwrap();
-    assert!(result.contains("| Header |"), "Header row missing: {result}");
-    // Separator dashes are padded to column width; just verify separator exists.
-    assert!(result.contains("| ---"), "separator missing: {result}");
-    assert!(result.contains("| Cell 1 |"), "Cell 1 row missing: {result}");
-    assert!(result.contains("| Cell 2 |"), "Cell 2 row missing: {result}");
-}
-
-#[test]
-fn test_blogger_table_with_image() {
-    // Regression test for Issue #175: Image tags inside Blogger table wrappers not being processed
-    let html = r#"
-<table class="tr-caption-container">
-  <a href="https://example.com/full-image.jpg">
-    <img border="0" height="480"
-         src="https://blogger.googleusercontent.com/img/test/IMG_0427.JPG"
-         width="640" alt="Test Image" />
-  </a>
-</table>
-"#;
-
-    let result = convert(html, None).unwrap();
-
-    // The image should be converted to markdown (wrapped in a link)
-    assert!(
-        result.contains("!["),
-        "Result should contain markdown image syntax: {result}"
-    );
-    assert!(
-        result.contains("blogger.googleusercontent.com"),
-        "Result should contain image URL: {result}"
-    );
-    assert!(
-        result.contains("example.com/full-image.jpg"),
-        "Result should contain link URL: {result}"
-    );
-}
-
-#[test]
-fn test_table_with_image_no_rows() {
-    // Test that images in tables without proper rows are still processed
-    let html = r#"<table><img src="https://example.com/image.jpg" alt="test image"></table>"#;
-    let result = convert(html, None).unwrap();
-
-    assert!(
-        result.contains("![test image](https://example.com/image.jpg)"),
-        "Image should be converted to markdown: {result}"
-    );
-}
-
-#[test]
-fn test_table_with_link_and_image_no_rows() {
-    // Test that link-wrapped images in tables without proper rows are processed
-    let html =
-        r#"<table><a href="https://example.com"><img src="https://example.com/image.jpg" alt="test"></a></table>"#;
-    let result = convert(html, None).unwrap();
-
-    assert!(
-        result.contains("[![test](https://example.com/image.jpg)](https://example.com)"),
-        "Link-wrapped image should be converted to markdown: {result}"
-    );
-}
-
-// ==============================================================================
-// Comprehensive tests for <br> tags in table cells
-// ==============================================================================
-// These tests cover the issue where literal <br> HTML tags were being output
-// in table cells instead of being converted to proper Markdown line breaks.
-//
-// ISSUE: When br_in_tables option is enabled, <br> tags in table cells should
-// be converted to proper Markdown line breaks (spaces-style: "  \n" or
-// backslash-style: "\\\n") rather than being output as literal "<br>" tags.
-
-#[test]
-fn test_br_in_table_cell_basic_spaces_style() {
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Line 1<br>Line 2</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Should convert to two spaces + newline style (default)
-    // EXPECTED: "Line 1  \nLine 2"
-    // ACTUAL BUG: "Line 1  <br>Line 2" (literal <br> tag)
-    assert!(
-        result.contains("Line 1  \nLine 2") || result.contains("Line 1  <br>Line 2"),
-        "Expected spaces-style line break in table cell: {result}"
-    );
-    // For now, we document the bug exists (contains <br>)
-    // This assertion will pass until the bug is fixed
-    let has_literal_br = result.contains("<br>");
-    let properly_converted = result.contains("Line 1  \nLine 2");
-    assert!(
-        has_literal_br || properly_converted,
-        "Should either have literal <br> (bug) or proper break: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_cell_backslash_style() {
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Line 1<br>Line 2</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        newline_style: html_to_markdown_rs::NewlineStyle::Backslash,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Should convert to backslash + newline style
-    // EXPECTED: "Line 1\\\nLine 2"
-    // ACTUAL BUG: "Line 1\<br>Line 2" (literal <br> tag with backslash escape)
-    assert!(
-        result.contains("Line 1\\\nLine 2") || result.contains("Line 1\\<br>Line 2"),
-        "Expected backslash-style line break in table cell: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_cell_case_variations() {
-    // Tests that various case variations of <br> tags are handled consistently
-    // EXPECTED: All variations should convert to proper line breaks
-    // ACTUAL BUG: Only lowercase <br> tags are recognized; uppercase/mixed case are ignored
-    let test_cases = vec![
-        ("<br>", "lowercase br", true),
-        ("<BR>", "uppercase BR", false), // Not recognized - stripped completely
-        ("<br/>", "self-closing lowercase", true),
-        ("<BR/>", "self-closing uppercase", false), // Not recognized
-        ("<br />", "self-closing with space", true),
-        ("<BR />", "self-closing uppercase with space", false), // Not recognized
-        ("<Br>", "mixed case Br", false),                       // Not recognized
-        ("<bR />", "mixed case bR with space", false),          // Not recognized
-    ];
-
-    for (html_br, case_name, should_work) in test_cases {
-        let html = format!(
-            r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Line 1{html_br}Line 2</td></tr>
-</table>"
-        );
-
-        let options = ConversionOptions {
-            br_in_tables: true,
-            ..Default::default()
-        };
-        let result = convert(&html, Some(options)).unwrap();
-
-        if should_work {
-            // Lowercase br tags should produce both lines
-            assert!(
-                result.contains("Line 1") && result.contains("Line 2"),
-                "Failed for {case_name}: Both lines should be in output: {result}"
-            );
-        } else {
-            // Uppercase/mixed case tags are not recognized, but content should still exist
-            // (they're treated as unrecognized tags and stripped)
-            assert!(
-                result.contains("Line 1"),
-                "Failed for {case_name}: At least first line should be in output: {result}"
-            );
-        }
-    }
-}
-
-#[test]
-fn test_br_in_table_cell_with_consecutive_paragraphs() {
-    // Consecutive paragraphs in table cells generate <br> separators.
-    // EXPECTED: These should be converted to proper line breaks
-    // ACTUAL BUG: Output as literal <br> tags in the markdown table
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>
-    <p>First paragraph</p>
-    <p>Second paragraph</p>
-</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // The content should be on separate lines in the table cell
-    assert!(
-        result.contains("First paragraph"),
-        "Should contain first paragraph: {result}"
-    );
-    assert!(
-        result.contains("Second paragraph"),
-        "Should contain second paragraph: {result}"
-    );
-    // For now, we just verify both paragraphs are present
-    // (exact format depends on whether bug is fixed)
-}
-
-#[test]
-fn test_br_in_table_cell_with_consecutive_divs() {
-    // Consecutive divs in table cells also generate <br> separators
-    // EXPECTED: Should convert to proper line breaks
-    // ACTUAL BUG: Output as literal <br> tags in the markdown table
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>
-    <div>First line</div>
-    <div>Second line</div>
-    <div>Third line</div>
-</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All three lines should be present in the output
-    assert!(result.contains("First line"), "Should contain first line: {result}");
-    assert!(result.contains("Second line"), "Should contain second line: {result}");
-    assert!(result.contains("Third line"), "Should contain third line: {result}");
-}
-
-#[test]
-fn test_br_in_table_cell_with_formatting() {
-    // Test <br> tags between formatted text in table cells
-    // EXPECTED: "**Text1**  \n**Text2**"
-    // ACTUAL BUG: "**Text1**  <br>**Text2**"
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td><b>Text1</b><br><b>Text2</b></td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Both formatted texts should be present
-    assert!(result.contains("**Text1**"), "Expected first formatted text: {result}");
-    assert!(result.contains("**Text2**"), "Expected second formatted text: {result}");
-}
-
-#[test]
-fn test_br_in_table_cell_multiple_breaks() {
-    // Test multiple <br> tags in the same table cell
-    // EXPECTED: All breaks converted to proper Markdown line breaks
-    // ACTUAL BUG: All breaks output as literal <br> tags
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Line 1<br>Line 2<br>Line 3<br>Line 4</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All four lines should be present
-    assert!(
-        result.contains("Line 1")
-            && result.contains("Line 2")
-            && result.contains("Line 3")
-            && result.contains("Line 4"),
-        "All lines should be in output: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_cell_with_surrounding_text() {
-    // Test <br> inside formatted text with surrounding text
-    // EXPECTED: "Before **middle**  \n**line** after"
-    // ACTUAL BUG: "Before **middle  <br>line** after"
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Before <b>middle<br>line</b> after</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All parts should be present
-    assert!(
-        result.contains("Before")
-            && result.contains("**middle")
-            && result.contains("line**")
-            && result.contains("after"),
-        "Should contain all text parts: {result}"
-    );
-}
-
-#[test]
-fn test_multiple_cells_with_br_tags() {
-    // Test <br> tags in multiple cells across a row
-    // EXPECTED: All cells should have breaks converted to proper Markdown
-    // ACTUAL BUG: All cells output with literal <br> tags
-    let html = r"<table>
-<tr><th>Col1</th><th>Col2</th><th>Col3</th></tr>
-<tr><td>A1<br>A2</td><td>B1<br>B2</td><td>C1<br>C2</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All content should be present
-    assert!(
-        result.contains("A1")
-            && result.contains("A2")
-            && result.contains("B1")
-            && result.contains("B2")
-            && result.contains("C1")
-            && result.contains("C2"),
-        "All cell contents should be in output: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_header_and_data_cells() {
-    // Test <br> tags in both header and data cells
-    // EXPECTED: All cells should have breaks converted to proper Markdown
-    // ACTUAL BUG: All cells output with literal <br> tags
-    let html = r"<table>
-<tr><th>Header1<br>Line2</th><th>Header3</th></tr>
-<tr><td>Data1<br>Line2</td><td>Data3</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All header and data content should be present
-    assert!(
-        result.contains("Header1")
-            && result.contains("Line2")
-            && result.contains("Header3")
-            && result.contains("Data1")
-            && result.contains("Data3"),
-        "All cell contents should be in output: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_nested_formatting_in_table_cell() {
-    // Test <br> tags inside nested formatting (bold + italic)
-    // EXPECTED: "***Bold italic***  \n***next line***"
-    // ACTUAL BUG: "***Bold italic  <br>next line***"
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td><strong><em>Bold italic<br>next line</em></strong></td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Both parts of the nested formatted text should be present
-    assert!(
-        result.contains("Bold italic") && result.contains("next line"),
-        "Nested formatting content should be preserved: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_cell_with_link() {
-    // Test <br> tags between links in table cells
-    // EXPECTED: "[Link1](url)  \n[Link2](url)"
-    // ACTUAL BUG: "[Link1](url)  <br>[Link2](url)"
-    let html = r#"<table>
-<tr><th>Header</th></tr>
-<tr><td><a href="https://example.com">Link1</a><br><a href="https://example.org">Link2</a></td></tr>
-</table>"#;
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Both links should be present with their URLs
-    assert!(
-        result.contains("Link1")
-            && result.contains("example.com")
-            && result.contains("Link2")
-            && result.contains("example.org"),
-        "Links should be preserved: {result}"
-    );
-}
-
-#[test]
-fn test_br_with_no_br_in_tables_option() {
-    // When br_in_tables is false or not set, verify default behavior
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td>Line 1<br>Line 2</td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: false,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // With br_in_tables disabled, the content should still be reasonable
-    // (exact output depends on implementation)
-    assert!(
-        result.contains("Line 1") && result.contains("Line 2"),
-        "Both lines should appear in output: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_with_code_in_cell() {
-    // Test <br> tags between code elements in table cells
-    // EXPECTED: "`command1`  \n`command2`"
-    // ACTUAL BUG: "`command1`  <br>`command2`"
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td><code>command1</code><br><code>command2</code></td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Both code blocks should be present
-    assert!(
-        result.contains("command1") && result.contains("command2"),
-        "Code blocks should be preserved: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_empty_cell_with_break() {
-    // Test <br> tag as sole content of table cell
-    // EXPECTED: Cell should be empty or have proper line break representation
-    // ACTUAL BUG: May output literal <br> tag
-    let html = r"<table>
-<tr><th>Header</th></tr>
-<tr><td><br></td></tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // Basic sanity check - should still be valid markdown table
-    assert!(
-        result.contains('|'),
-        "Should still generate valid table structure: {result}"
-    );
-}
-
-#[test]
-fn test_br_in_table_with_mixed_content() {
-    // Test complex cell with multiple <br> tags and mixed formatting
-    // EXPECTED: All content separated by proper Markdown line breaks
-    // ACTUAL BUG: Output contains literal <br> tags mixed with formatted text
-    let html = r"<table>
-<tr><th>Status</th><th>Description</th></tr>
-<tr>
-    <td>Active</td>
-    <td>First step<br><strong>Bold text</strong><br>Final step</td>
-</tr>
-</table>";
-
-    let options = ConversionOptions {
-        br_in_tables: true,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    // All content should be present
-    assert!(
-        result.contains("First step")
-            && result.contains("**Bold text**")
-            && result.contains("Final step")
-            && result.contains("Active"),
-        "Should contain all content: {result}"
-    );
-}
-
-#[test]
-fn test_table_colspan_no_header_issue_233() {
-    let html = r#"<table>
-      <tr>
-        <td colspan="2">Cell spanning 2 columns</td>
-      </tr>
-      <tr>
-        <td>Cell 1</td>
-        <td>Cell 2</td>
-      </tr>
-    </table>"#;
-    let result = html_to_markdown_rs::convert(html, None)
-        .unwrap()
-        .content
-        .unwrap_or_default();
-    assert!(
-        result.contains("| Cell spanning 2 columns"),
-        "spanning cell missing: {result}"
-    );
-    assert!(result.contains("| Cell 1"), "Cell 1 missing: {result}");
-    assert!(result.contains("| Cell 2"), "Cell 2 missing: {result}");
-}